Apple WWDC 1996/WWDC96_1996 (CD).toast/Technology Materials/MacOS 8 Resources/Developer Tools/Mac OS 8 Interfaces & Libraries/Interfaces/CIncludes/GXPrinting.h

C/C++ Source or Header | 1996-05-01 | 155.0 KB | 4,597 lines | [TEXT/MPS ]

/*
     File:        GXPrinting.h

     Contains:    This file contains all printing APIs except for driver/extension specific ones.

     Version:    Technology:    Quickdraw GX 1.1
                 Release:    Universal Interfaces 3.0d3 on Copland DR1

     Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.

     Bugs?:        If you find a problem with this file, send the file and version
                 information (from above) and the problem description to:

                     Internet:    [e-mail]
                     AppleLink:    APPLE.BUGS

*/
#ifndef __GXPRINTING__
#define __GXPRINTING__

#ifndef __COLLECTIONS__
#include <Collections.h>
#endif
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
#ifndef __DIALOGS__
#include <Dialogs.h>
#endif
#ifndef __ERRORS__
#include <Errors.h>
#endif
#ifndef __FILES__
#include <Files.h>
#endif
#ifndef __GXFONTS__
#include <GXFonts.h>
#endif
#ifndef __GXMATH__
#include <GXMath.h>
#endif
#ifndef __GXTYPES__
#include <GXTypes.h>
#endif
#ifndef __LISTS__
#include <Lists.h>
#endif
#ifndef __MENUS__
#include <Menus.h>
#endif
#ifndef __GXMESSAGES__
#include <GXMessages.h>
#endif
#ifndef __PRINTING__
#include <Printing.h>
#endif
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if PRAGMA_IMPORT_SUPPORTED
#pragma import on
#endif

#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=mac68k
#endif

#if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE
/*
*******************************************************************
                    Start of old "GXPrintingManager.h/a/p" interface file.
            ********************************************************************
*/
/*
 ------------------------------------------------------------------------------

                            Printing Manager API Contants and Types

--------------------------------------------------------------------------------
*/
/* QuickDraw GX Printing Manager & Overall GX Gestalt Selectors */

enum {
    gestaltGXPrintingMgrVersion    = 'pmgr',
    gestaltGXVersion            = 'qdgx'
};

typedef unsigned long gxOwnerSignature;
#if OLDROUTINENAMES
typedef unsigned long Signature;
#endif
/*

    ABSTRACT DATA TYPES

*/
/*
 typedef struct gxPrivatePrinterRecord *gxPrinter;
 typedef struct gxPrivateJobRecord *gxJob;
 typedef struct gxPrivateFormatRecord *gxFormat;
 typedef struct gxPrivatePaperTypeRecord *gxPaperType;
 typedef struct gxPrivatePrintFileRecord *gxPrintFile;
*/
typedef struct OpaquegxPrinter* gxPrinter;
typedef struct OpaquegxJob* gxJob;
typedef struct OpaquegxFormat* gxFormat;
typedef struct OpaquegxPaperType* gxPaperType;
typedef struct OpaquegxPrintFile* gxPrintFile;
/* Possible values for LoopStatus */
typedef Boolean gxLoopStatus;

enum {
    gxStopLooping                = false,
    gxKeepLooping                = true
};

typedef pascal gxLoopStatus (*GXViewDeviceProcPtr)(gxViewDevice aViewDevice, void *refCon);

#if GENERATINGCFM
typedef UniversalProcPtr GXViewDeviceUPP;
#else
typedef GXViewDeviceProcPtr GXViewDeviceUPP;
#endif

enum {
    uppGXViewDeviceProcInfo = kPascalStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(gxLoopStatus)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxViewDevice)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXViewDeviceProc(userRoutine)        \
        (GXViewDeviceUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXViewDeviceProcInfo, GetCurrentArchitecture())
#else
#define NewGXViewDeviceProc(userRoutine)        \
        ((GXViewDeviceUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXViewDeviceProc(userRoutine, aViewDevice, refCon)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXViewDeviceProcInfo, (aViewDevice), (refCon))
#else
#define CallGXViewDeviceProc(userRoutine, aViewDevice, refCon)        \
        (*(userRoutine))((aViewDevice), (refCon))
#endif
typedef pascal gxLoopStatus (*GXFormatProcPtr)(gxFormat aFormat, void *refCon);

#if GENERATINGCFM
typedef UniversalProcPtr GXFormatUPP;
#else
typedef GXFormatProcPtr GXFormatUPP;
#endif

enum {
    uppGXFormatProcInfo = kPascalStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(gxLoopStatus)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXFormatProc(userRoutine)        \
        (GXFormatUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFormatProcInfo, GetCurrentArchitecture())
#else
#define NewGXFormatProc(userRoutine)        \
        ((GXFormatUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFormatProc(userRoutine, aFormat, refCon)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFormatProcInfo, (aFormat), (refCon))
#else
#define CallGXFormatProc(userRoutine, aFormat, refCon)        \
        (*(userRoutine))((aFormat), (refCon))
#endif
typedef pascal gxLoopStatus (*GXPaperTypeProcPtr)(gxPaperType aPapertype, void *refCon);

#if GENERATINGCFM
typedef UniversalProcPtr GXPaperTypeUPP;
#else
typedef GXPaperTypeProcPtr GXPaperTypeUPP;
#endif

enum {
    uppGXPaperTypeProcInfo = kPascalStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(gxLoopStatus)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPaperType)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXPaperTypeProc(userRoutine)        \
        (GXPaperTypeUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXPaperTypeProcInfo, GetCurrentArchitecture())
#else
#define NewGXPaperTypeProc(userRoutine)        \
        ((GXPaperTypeUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXPaperTypeProc(userRoutine, aPapertype, refCon)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXPaperTypeProcInfo, (aPapertype), (refCon))
#else
#define CallGXPaperTypeProc(userRoutine, aPapertype, refCon)        \
        (*(userRoutine))((aPapertype), (refCon))
#endif
typedef pascal OSErr (*GXPrintingFlattenProcPtr)(long size, void *data, void *refCon);

#if GENERATINGCFM
typedef UniversalProcPtr GXPrintingFlattenUPP;
#else
typedef GXPrintingFlattenProcPtr GXPrintingFlattenUPP;
#endif

enum {
    uppGXPrintingFlattenProcInfo = kPascalStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXPrintingFlattenProc(userRoutine)        \
        (GXPrintingFlattenUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXPrintingFlattenProcInfo, GetCurrentArchitecture())
#else
#define NewGXPrintingFlattenProc(userRoutine)        \
        ((GXPrintingFlattenUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXPrintingFlattenProc(userRoutine, size, data, refCon)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXPrintingFlattenProcInfo, (size), (data), (refCon))
#else
#define CallGXPrintingFlattenProc(userRoutine, size, data, refCon)        \
        (*(userRoutine))((size), (data), (refCon))
#endif
#if OLDROUTINENAMES
typedef GXViewDeviceProcPtr gxViewDeviceProc;
typedef GXFormatProcPtr gxFormatProc;
typedef GXPaperTypeProcPtr gxPaperTypeProc;
typedef GXPrintingFlattenProcPtr gxPrintingFlattenProc;
#endif
/*
    The following constants are used to set collection item flags in printing
    collections. The Printing Manager purges certain items whenever a driver
    switch occurs. If the formatting driver changes, all items marked as
    gxVolatileFormattingDriverCategory will be purged.  If the output driver
    changes, all items marked as gxVolatileOutputDriverCategory will be purged.
    Note that to prevent items from being flattened when GXFlattenJob is called,
    you should unset the collectionPersistenceBit (defined in Collections.h),
    which is on by default.
*/
/* Structure stored in collection items' user attribute bits */
typedef short gxCollectionCategory;

enum {
    gxNoCollectionCategory        = 0x0000,
    gxOutputDriverCategory        = 0x0001,
    gxFormattingDriverCategory    = 0x0002,
    gxDriverVolatileCategory    = 0x0004,
    gxVolatileOutputDriverCategory = gxOutputDriverCategory + gxDriverVolatileCategory,
    gxVolatileFormattingDriverCategory = gxFormattingDriverCategory + gxDriverVolatileCategory
};

/*

    >>>>>> JOB COLLECTION ITEMS <<<<<<

*/
/* gxJobInfo COLLECTION ITEM */

enum {
    gxJobTag                    = 'job '
};

struct gxJobInfo {
    long                             numPages;                    /* Number of pages in the document */
    long                             priority;                    /* Priority of this job plus "is it on hold?" */
    unsigned long                     timeToPrint;                /* When to print job, if scheduled */
    long                             jobTimeout;                    /* Timeout value, in ticks */
    long                             firstPageToPrint;            /* Start printing from this page */
    short                             jobAlert;                    /* How to alert user when printing */
    Str31                             appName;                    /* Which application printed the document */
    Str31                             documentName;                /* The name of the document being printed */
    Str31                             userName;                    /* The owner name of the machine that printed the document */
};
typedef struct gxJobInfo gxJobInfo;

/* gxPDDDefaultSettingTag COLLECTION ITEM */

enum {
    gxPDDDefaultSettingTag        = 'pdds'
};

struct gxPDDDefaultSettingInfo {
    Boolean                         useDefaultSetting;            /* true if PDD default setting should be used */
    SInt8                             pad;
};
typedef struct gxPDDDefaultSettingInfo gxPDDDefaultSettingInfo;

/* priority field constants */

enum {
    gxPrintJobHoldingBit        = 0x00001000                    /* This bit is set if the job is on hold. */
};


enum {
    gxPrintJobUrgent            = 0x00000001,
    gxPrintJobAtTime            = 0x00000002,
    gxPrintJobASAP                = 0x00000003,
    gxPrintJobHolding            = (gxPrintJobHoldingBit + gxPrintJobASAP),
    gxPrintJobHoldingAtTime        = (gxPrintJobHoldingBit + gxPrintJobAtTime),
    gxPrintJobHoldingUrgent        = (gxPrintJobHoldingBit + gxPrintJobUrgent)
};

/* jobAlert field constants */

enum {
    gxNoPrintTimeAlert            = 0,                            /* Don't alert user when we print */
    gxAlertBefore                = 1,                            /* Alert user before we print */
    gxAlertAfter                = 2,                            /* Alert user after we print */
    gxAlertBothTimes            = 3                                /* Alert before and after we print */
};

/* jobTimeout field constants */

enum {
    gxThirtySeconds                = 1800,                            /* 30 seconds in ticks */
    gxTwoMinutes                = 7200                            /* 2 minutes in ticks */
};

/* gxCollationTag COLLECTION ITEM */

enum {
    gxCollationTag                = 'sort'
};

struct gxCollationInfo {
    Boolean                         collation;                    /* True if copies are to be collated */
    char                             padByte;
};
typedef struct gxCollationInfo gxCollationInfo;

/* gxCopiesTag COLLECTION ITEM */

enum {
    gxCopiesTag                    = 'copy'
};

struct gxCopiesInfo {
    long                             copies;                        /* Number of copies of the document to print */
};
typedef struct gxCopiesInfo gxCopiesInfo;

/* gxPageRangeTag COLLECTION ITEM */

enum {
    gxPageRangeTag                = 'rang'
};

struct gxSimplePageRangeInfo {
    char                             optionChosen;                /* From options listed below */
    Boolean                         printAll;                    /* True if user wants to print all pages */
    long                             fromPage;                    /* For gxDefaultPageRange, current value */
    long                             toPage;                        /* For gxDefaultPageRange, current value */
};
typedef struct gxSimplePageRangeInfo gxSimplePageRangeInfo;

struct gxPageRangeInfo {
    gxSimplePageRangeInfo             simpleRange;                /* Info which will be returned for GetJobPageRange */
    Str31                             fromString;                    /* For gxCustomizePageRange, current value */
    Str31                             toString;                    /* For gxCustomizePageRange, current value */
    long                             minFromPage;                /* For gxDefaultPageRange, we parse with this, ignored if nil */
    long                             maxToPage;                    /* For gxDefaultPageRange, we parse with this, ignored if nil */
    char                             replaceString[1];            /* For gxReplacePageRange, string to display */
};
typedef struct gxPageRangeInfo gxPageRangeInfo;

/* optionChosen field constants for SimplePageRangeInfo */

enum {
    gxDefaultPageRange            = 0,
    gxReplacePageRange            = 1,
    gxCustomizePageRange        = 2
};

/* gxQualityTag COLLECTION ITEM */

enum {
    gxQualityTag                = 'qual'
};

struct gxQualityInfo {
    Boolean                         disableQuality;                /* True to disable standard quality controls */
    char                             padByte;
    short                             defaultQuality;                /* The default quality value */
    short                             currentQuality;                /* The current quality value */
    short                             qualityCount;                /* The number of quality menu items in popup menu */
    char                             qualityNames[1];            /* An array of packed pascal strings for popup menu titles */
};
typedef struct gxQualityInfo gxQualityInfo;

/* gxFileDestinationTag COLLECTION ITEM */

enum {
    gxFileDestinationTag        = 'dest'
};

struct gxFileDestinationInfo {
    Boolean                         toFile;                        /* True if destination is a file */
    char                             padByte;
};
typedef struct gxFileDestinationInfo gxFileDestinationInfo;

/* gxFileLocationTag COLLECTION ITEM */

enum {
    gxFileLocationTag            = 'floc'
};

struct gxFileLocationInfo {
    FSSpec                             fileSpec;                    /* Location to put file, if destination is file */
};
typedef struct gxFileLocationInfo gxFileLocationInfo;

/* gxFileFormatTag COLLECTION ITEM */

enum {
    gxFileFormatTag                = 'ffmt'
};

struct gxFileFormatInfo {
    Str31                             fileFormatName;                /* Name of file format (e.g. "PostScript") if destination is file */
};
typedef struct gxFileFormatInfo gxFileFormatInfo;

/* gxFileFontsTag COLLECTION ITEM */

enum {
    gxFileFontsTag                = 'incf'
};

struct gxFileFontsInfo {
    char                             includeFonts;                /* Which fonts to include, if destination is file */
    char                             padByte;
};
typedef struct gxFileFontsInfo gxFileFontsInfo;

/* includeFonts field constants */

enum {
    gxIncludeNoFonts            = 1,                            /* Include no fonts */
    gxIncludeAllFonts            = 2,                            /* Include all fonts */
    gxIncludeNonStandardFonts    = 3                                /* Include only fonts that aren't in the standard LW set */
};

/* gxPaperFeedTag COLLECTION ITEM */

enum {
    gxPaperFeedTag                = 'feed'
};

struct gxPaperFeedInfo {
    Boolean                         autoFeed;                    /* True if automatic feed, false if manual */
    char                             padByte;
};
typedef struct gxPaperFeedInfo gxPaperFeedInfo;

/* gxTrayFeedTag COLLECTION ITEM */

enum {
    gxTrayFeedTag                = 'tray'
};

typedef long gxTrayIndex;
struct gxTrayFeedInfo {
    gxTrayIndex                     feedTrayIndex;                /* Tray to feed paper from */
    Boolean                         manualFeedThisPage;            /* Signals manual feeding for the page */
    char                             padByte;
};
typedef struct gxTrayFeedInfo gxTrayFeedInfo;

/* gxManualFeedTag COLLECTION ITEM */

enum {
    gxManualFeedTag                = 'manf'
};

struct gxManualFeedInfo {
    long                             numPaperTypeNames;            /* Number of paperTypes to manually feed */
    Str31                             paperTypeNames[1];            /* Array of names of paperTypes to manually feed */
};
typedef struct gxManualFeedInfo gxManualFeedInfo;

/* gxNormalMappingTag COLLECTION ITEM */

enum {
    gxNormalMappingTag            = 'nmap'
};

struct gxNormalMappingInfo {
    Boolean                         normalPaperMapping;            /* True if not overriding normal paper mapping */
    char                             padByte;
};
typedef struct gxNormalMappingInfo gxNormalMappingInfo;

/* gxSpecialMappingTag COLLECTION ITEM */

enum {
    gxSpecialMappingTag            = 'smap'
};

struct gxSpecialMappingInfo {
    char                             specialMapping;                /* Enumerated redirect, scale or tile setting */
    char                             padByte;
};
typedef struct gxSpecialMappingInfo gxSpecialMappingInfo;

/* specialMapping field constants */

enum {
    gxRedirectPages                = 1,                            /* Redirect pages to a papertype and clip if necessary */
    gxScalePages                = 2,                            /* Scale pages if necessary */
    gxTilePages                    = 3                                /* Tile pages if necessary */
};

/* gxTrayMappingTag COLLECTION ITEM */

enum {
    gxTrayMappingTag            = 'tmap'
};

struct gxTrayMappingInfo {
    gxTrayIndex                     mapPaperToTray;                /* Tray to map all paper to */
};
typedef struct gxTrayMappingInfo gxTrayMappingInfo;

/* gxPaperMappingTag COLLECTION ITEM */
/* This collection item contains a flattened paper type resource */

enum {
    gxPaperMappingTag            = 'pmap'
};

/* gxPrintPanelTag COLLECTION ITEM */

enum {
    gxPrintPanelTag                = 'ppan'
};

struct gxPrintPanelInfo {
    Str31                             startPanelName;                /* Name of starting panel in Print dialog */
};
typedef struct gxPrintPanelInfo gxPrintPanelInfo;

/* gxFormatPanelTag COLLECTION ITEM */

enum {
    gxFormatPanelTag            = 'fpan'
};

struct gxFormatPanelInfo {
    Str31                             startPanelName;                /* Name of starting panel in Format dialog */
};
typedef struct gxFormatPanelInfo gxFormatPanelInfo;

/* gxTranslatedDocumentTag COLLECTION ITEM */

enum {
    gxTranslatedDocumentTag        = 'trns'
};

struct gxTranslatedDocumentInfo {
    long                             translatorInfo;                /* Information from the translation process */
};
typedef struct gxTranslatedDocumentInfo gxTranslatedDocumentInfo;

/* gxCoverPageTag COLLECTION ITEM */

enum {
    gxCoverPageTag                = 'cvpg'
};

struct gxCoverPageInfo {
    long                             coverPage;                    /* Use same enum values as for PrintRecord field in GXPrinterDrivers.h */
};
typedef struct gxCoverPageInfo gxCoverPageInfo;

/*

    >>>>>> FORMAT COLLECTION ITEMS <<<<<<

*/
/* gxPaperTypeLockTag COLLECTION ITEM */

enum {
    gxPaperTypeLockTag            = 'ptlk'
};

struct gxPaperTypeLockInfo {
    Boolean                         paperTypeLocked;            /* True if format's paperType is locked */
    char                             padByte;
};
typedef struct gxPaperTypeLockInfo gxPaperTypeLockInfo;

/* gxOrientationTag COLLECTION ITEM */

enum {
    gxOrientationTag            = 'layo'
};

struct gxOrientationInfo {
    char                             orientation;                /* An enumerated orientation value */
    char                             padByte;
};
typedef struct gxOrientationInfo gxOrientationInfo;

/* orientation field constants */

enum {
    gxPortraitLayout            = 0,                            /* Portrait */
    gxLandscapeLayout            = 1,                            /* Landscape */
    gxRotatedPortraitLayout        = 2,                            /* Portrait, rotated 180° */
    gxRotatedLandscapeLayout    = 3                                /* Landscape, rotated 180°  */
};

/* gxScalingTag COLLECTION ITEM */

enum {
    gxScalingTag                = 'scal'
};

struct gxScalingInfo {
    Fixed                             horizontalScaleFactor;        /* Current horizontal scaling factor */
    Fixed                             verticalScaleFactor;        /* Current vertical scaling factor */
    short                             minScaling;                    /* Minimum scaling allowed */
    short                             maxScaling;                    /* Maximum scaling allowed */
};
typedef struct gxScalingInfo gxScalingInfo;

/* gxDirectModeTag COLLECTION ITEM */

enum {
    gxDirectModeTag                = 'dirm'
};

struct gxDirectModeInfo {
    Boolean                         directModeOn;                /* True if a direct mode is enabled */
    char                             padByte;
};
typedef struct gxDirectModeInfo gxDirectModeInfo;

/* gxFormatHalftoneTag COLLECTION ITEM */

enum {
    gxFormatHalftoneTag            = 'half'
};

struct gxFormatHalftoneInfo {
    long                             numHalftones;                /* Number of halftone records */
    gxHalftone                         halftones[1];                /* The halftone records */
};
typedef struct gxFormatHalftoneInfo gxFormatHalftoneInfo;

/* gxInvertPageTag COLLECTION ITEM */

enum {
    gxInvertPageTag                = 'invp'
};

struct gxInvertPageInfo {
    char                             padByte;
    Boolean                         invert;                        /* If true, invert page */
};
typedef struct gxInvertPageInfo gxInvertPageInfo;

/* gxFlipPageHorizontalTag COLLECTION ITEM */

enum {
    gxFlipPageHorizontalTag        = 'flph'
};

struct gxFlipPageHorizontalInfo {
    char                             padByte;
    Boolean                         flipHorizontal;                /* If true, flip x coordinates on page */
};
typedef struct gxFlipPageHorizontalInfo gxFlipPageHorizontalInfo;

/* gxFlipPageVerticalTag COLLECTION ITEM */

enum {
    gxFlipPageVerticalTag        = 'flpv'
};

struct gxFlipPageVerticalInfo {
    char                             padByte;
    Boolean                         flipVertical;                /* If true, flip y coordinates on page */
};
typedef struct gxFlipPageVerticalInfo gxFlipPageVerticalInfo;

/* gxPreciseBitmapsTag COLLECTION ITEM */

enum {
    gxPreciseBitmapsTag            = 'pbmp'
};

struct gxPreciseBitmapInfo {
    Boolean                         preciseBitmaps;                /* If true, scale page by 96% */
    char                             padByte;
};
typedef struct gxPreciseBitmapInfo gxPreciseBitmapInfo;

/*

    >>>>>> PAPERTYPE COLLECTION ITEMS <<<<<<

*/
/* gxBaseTag COLLECTION ITEM */

enum {
    gxBaseTag                    = 'base'
};

struct gxBaseInfo {
    long                             baseType;                    /* PaperType's base type */
};
typedef struct gxBaseInfo gxBaseInfo;

/* baseType field constants */

enum {
    gxUnknownBase                = 0,                            /* Base paper type from which this paper type is */
    gxUSLetterBase                = 1,                            /* derived.  This is not a complete set. */
    gxUSLegalBase                = 2,
    gxA4LetterBase                = 3,
    gxB5LetterBase                = 4,
    gxTabloidBase                = 5
};

/* gxCreatorTag COLLECTION ITEM */

enum {
    gxCreatorTag                = 'crea'
};

struct gxCreatorInfo {
    OSType                             creator;                    /* PaperType's creator */
};
typedef struct gxCreatorInfo gxCreatorInfo;

/* gxUnitsTag COLLECTION ITEM */

enum {
    gxUnitsTag                    = 'unit'
};

struct gxUnitsInfo {
    char                             units;                        /* PaperType's units (used by PaperType Editor). */
    char                             padByte;
};
typedef struct gxUnitsInfo gxUnitsInfo;

/* units field constants */

enum {
    gxPicas                        = 0,                            /* Pica measurement */
    gxMMs                        = 1,                            /* Millimeter measurement */
    gxInches                    = 2                                /* Inches measurement */
};

/* gxFlagsTag COLLECTION ITEM */

enum {
    gxFlagsTag                    = 'flag'
};

struct gxFlagsInfo {
    long                             flags;                        /* PaperType's flags */
};
typedef struct gxFlagsInfo gxFlagsInfo;

/* flags field constants */

enum {
    gxOldPaperTypeFlag            = 0x00800000,                    /* Indicates a paper type for compatibility printing */
    gxNewPaperTypeFlag            = 0x00400000,                    /* Indicates a paper type for QuickDraw GX-aware printing */
    gxOldAndNewFlag                = 0x00C00000,                    /* Indicates a paper type that's both old and new */
    gxDefaultPaperTypeFlag        = 0x00100000                    /* Indicates the default paper type in the group */
};

/* gxCommentTag COLLECTION ITEM */

enum {
    gxCommentTag                = 'cmnt'
};

struct gxCommentInfo {
    Str255                             comment;                    /* PaperType's comment */
};
typedef struct gxCommentInfo gxCommentInfo;

/*

    >>>>>> PRINTER VIEWDEVICE TAGS <<<<<<

*/
/* gxPenTableTag COLLECTION ITEM */

enum {
    gxPenTableTag                = 'pent'
};

struct gxPenTableEntry {
    Str31                             penName;                    /* Name of the pen */
    gxColor                         penColor;                    /* Color to use from the color set */
    Fixed                             penThickness;                /* Size of the pen */
    short                             penUnits;                    /* Specifies units in which pen thickness is defined */
    short                             penPosition;                /* Pen position in the carousel, -1 (kPenNotLoaded) if not loaded */
};
typedef struct gxPenTableEntry gxPenTableEntry;

struct gxPenTable {
    long                             numPens;                    /* Number of pen entries in the following array */
    gxPenTableEntry                 pens[1];                    /* Array of pen entries */
};
typedef struct gxPenTable gxPenTable;

typedef gxPenTable *gxPenTablePtr;
typedef gxPenTablePtr *gxPenTableHdl;
/* penUnits field constants */

enum {
    gxDeviceUnits                = 0,
    gxMMUnits                    = 1,
    gxInchesUnits                = 2
};

/* penPosition field constants */

enum {
    gxPenNotLoaded                = -1
};

/*

    >>>>>> DIALOG-RELATED CONSTANTS AND TYPES <<<<<<

*/
typedef long gxDialogResult;

enum {
    gxCancelSelected            = 0L,
    gxOKSelected                = 1L,
    gxRevertSelected            = 2L
};

struct gxEditMenuRecord {
    short                             editMenuID;
    short                             cutItem;
    short                             copyItem;
    short                             pasteItem;
    short                             clearItem;
    short                             undoItem;
};
typedef struct gxEditMenuRecord gxEditMenuRecord;

/*

    >>>>>> JOB FORMAT MODE CONSTANTS AND TYPES <<<<<<

*/
typedef OSType gxJobFormatMode;
struct gxJobFormatModeTable {
    long                             numModes;                    /* Number of job format modes to choose from */
    gxJobFormatMode                 modes[1];                    /* The job format modes */
};
typedef struct gxJobFormatModeTable gxJobFormatModeTable;

typedef gxJobFormatModeTable *gxJobFormatModeTablePtr;
typedef gxJobFormatModeTablePtr *gxJobFormatModeTableHdl;

enum {
    gxGraphicsJobFormatMode        = 'grph',
    gxTextJobFormatMode            = 'text',
    gxPostScriptJobFormatMode    = 'post'
};

typedef long gxQueryType;

enum {
    gxGetJobFormatLineConstraintQuery = 0L,
    gxGetJobFormatFontsQuery    = 1L,
    gxGetJobFormatFontCommonStylesQuery = 2L,
    gxGetJobFormatFontConstraintQuery = 3L,
    gxSetStyleJobFormatCommonStyleQuery = 4L
};

/* Structures used for Text mode field constants */
struct gxPositionConstraintTable {
    gxPoint                         phase;                        /* Position phase */
    gxPoint                         offset;                        /* Position offset */
    long                             numSizes;                    /* Number of available font sizes */
    Fixed                             sizes[1];                    /* The available font sizes */
};
typedef struct gxPositionConstraintTable gxPositionConstraintTable;

typedef gxPositionConstraintTable *gxPositionConstraintTablePtr;
typedef gxPositionConstraintTablePtr *gxPositionConstraintTableHdl;
/* numSizes field constants */

enum {
    gxConstraintRange            = -1
};

struct gxStyleNameTable {
    long                             numStyleNames;                /* Number of style names */
    Str255                             styleNames[1];                /* The style names */
};
typedef struct gxStyleNameTable gxStyleNameTable;

typedef gxStyleNameTable *gxStyleNameTablePtr;
typedef gxStyleNameTablePtr *gxStyleNameTableHdl;
struct gxFontTable {
    long                             numFonts;                    /* Number of font references */
    gxFont                             fonts[1];                    /* The font references */
};
typedef struct gxFontTable gxFontTable;

typedef gxFontTable *gxFontTablePtr;
typedef gxFontTablePtr *gxFontTableHdl;
/*
 ------------------------------------------------------------------------------

                                Printing Manager API Functions

--------------------------------------------------------------------------------
*/
/*
    Global Routines
*/
extern pascal OSErr GXInitPrinting(void )
 FOURWORDINLINE(0x203C, 0x0000, 0x0000, 0xABFE);

extern pascal OSErr GXExitPrinting(void )
 FOURWORDINLINE(0x203C, 0x0000, 0x0001, 0xABFE);

/*
    Error-Handling Routines
*/
extern pascal OSErr GXGetJobError(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x000E, 0xABFE);

extern pascal void GXSetJobError(gxJob aJob, OSErr anErr)
 FOURWORDINLINE(0x203C, 0x0000, 0x000F, 0xABFE);

/*
    Job Routines
*/
extern pascal OSErr GXNewJob(gxJob *aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0002, 0xABFE);

extern pascal OSErr GXDisposeJob(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0003, 0xABFE);

extern pascal void GXFlattenJob(gxJob aJob, GXPrintingFlattenUPP flattenProc, void *aVoid)
 FOURWORDINLINE(0x203C, 0x0000, 0x0004, 0xABFE);

extern pascal gxJob GXUnflattenJob(gxJob aJob, GXPrintingFlattenUPP flattenProc, void *aVoid)
 FOURWORDINLINE(0x203C, 0x0000, 0x0005, 0xABFE);

extern pascal Handle GXFlattenJobToHdl(gxJob aJob, Handle aHdl)
 FOURWORDINLINE(0x203C, 0x0000, 0x0006, 0xABFE);

extern pascal gxJob GXUnflattenJobFromHdl(gxJob aJob, Handle aHdl)
 FOURWORDINLINE(0x203C, 0x0000, 0x0007, 0xABFE);

extern pascal void GXInstallApplicationOverride(gxJob aJob, short messageID, void *override)
 FOURWORDINLINE(0x203C, 0x0000, 0x0008, 0xABFE);

extern pascal Collection GXGetJobCollection(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x001D, 0xABFE);

extern pascal void *GXGetJobRefCon(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x001E, 0xABFE);

extern pascal void GXSetJobRefCon(gxJob aJob, void *refCon)
 FOURWORDINLINE(0x203C, 0x0000, 0x001F, 0xABFE);

extern pascal gxJob GXCopyJob(gxJob srcJob, gxJob dstJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0020, 0xABFE);

extern pascal void GXSelectJobFormattingPrinter(gxJob aJob, Str31 printerName)
 FOURWORDINLINE(0x203C, 0x0000, 0x0021, 0xABFE);

extern pascal void GXSelectJobOutputPrinter(gxJob aJob, Str31 printerName)
 FOURWORDINLINE(0x203C, 0x0000, 0x0022, 0xABFE);

extern pascal void GXForEachJobFormatDo(gxJob aJob, GXFormatUPP formatProc, void *refCon)
 FOURWORDINLINE(0x203C, 0x0000, 0x0023, 0xABFE);

extern pascal long GXCountJobFormats(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0024, 0xABFE);

extern pascal Boolean GXUpdateJob(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0025, 0xABFE);

#endif
#if FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED
extern pascal void GXConvertPrintRecord(gxJob aJob, THPrint hPrint)
 FOURWORDINLINE(0x203C, 0x0000, 0x0026, 0xABFE);

#endif
#if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE
extern pascal void GXIdleJob(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0057, 0xABFE);

/*
    Job Format Modes Routines
*/
extern pascal void GXSetAvailableJobFormatModes(gxJob aJob, gxJobFormatModeTableHdl formatModeTable)
 FOURWORDINLINE(0x203C, 0x0000, 0x003B, 0xABFE);

extern pascal gxJobFormatMode GXGetPreferredJobFormatMode(gxJob aJob, Boolean *directOnly)
 FOURWORDINLINE(0x203C, 0x0000, 0x003C, 0xABFE);

extern pascal gxJobFormatMode GXGetJobFormatMode(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x003D, 0xABFE);

extern pascal void GXSetJobFormatMode(gxJob aJob, gxJobFormatMode formatMode)
 FOURWORDINLINE(0x203C, 0x0000, 0x003E, 0xABFE);

extern pascal void GXJobFormatModeQuery(gxJob aJob, gxQueryType aQueryType, void *srcData, void *dstData)
 FOURWORDINLINE(0x203C, 0x0000, 0x003F, 0xABFE);

/*
    Format Routines
*/
extern pascal gxFormat GXNewFormat(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0009, 0xABFE);

extern pascal void GXDisposeFormat(gxFormat aFormat)
 FOURWORDINLINE(0x203C, 0x0000, 0x000A, 0xABFE);

extern pascal gxFormat GXGetJobFormat(gxJob aJob, long whichFormat)
 FOURWORDINLINE(0x203C, 0x0000, 0x0013, 0xABFE);

extern pascal gxJob GXGetFormatJob(gxFormat aFormat)
 FOURWORDINLINE(0x203C, 0x0000, 0x0014, 0xABFE);

extern pascal gxPaperType GXGetFormatPaperType(gxFormat aFormat)
 FOURWORDINLINE(0x203C, 0x0000, 0x0015, 0xABFE);

extern pascal void GXGetFormatDimensions(gxFormat aFormat, gxRectangle *pageSize, gxRectangle *paperSize)
 FOURWORDINLINE(0x203C, 0x0000, 0x0016, 0xABFE);

extern pascal Collection GXGetFormatCollection(gxFormat aFormat)
 FOURWORDINLINE(0x203C, 0x0000, 0x0033, 0xABFE);

extern pascal void GXChangedFormat(gxFormat aFormat)
 FOURWORDINLINE(0x203C, 0x0000, 0x0034, 0xABFE);

extern pascal gxFormat GXCopyFormat(gxFormat srcFormat, gxFormat dstFormat)
 FOURWORDINLINE(0x203C, 0x0000, 0x0035, 0xABFE);

extern pascal gxFormat GXCloneFormat(gxFormat aFormat)
 FOURWORDINLINE(0x203C, 0x0000, 0x0036, 0xABFE);

extern pascal long GXCountFormatOwners(gxFormat aFormat)
 FOURWORDINLINE(0x203C, 0x0000, 0x0037, 0xABFE);

extern pascal void GXGetFormatMapping(gxFormat aFormat, gxMapping *fmtMapping)
 FOURWORDINLINE(0x203C, 0x0000, 0x0038, 0xABFE);

extern pascal gxShape GXGetFormatForm(gxFormat aFormat, gxShape *mask)
 FOURWORDINLINE(0x203C, 0x0000, 0x0039, 0xABFE);

extern pascal void GXSetFormatForm(gxFormat aFormat, gxShape form, gxShape mask)
 FOURWORDINLINE(0x203C, 0x0000, 0x003A, 0xABFE);

/*
    PaperType Routines
*/
extern pascal gxPaperType GXNewPaperType(gxJob aJob, Str31 name, gxRectangle *pageSize, gxRectangle *paperSize)
 FOURWORDINLINE(0x203C, 0x0000, 0x000B, 0xABFE);

extern pascal void GXDisposePaperType(gxPaperType aPaperType)
 FOURWORDINLINE(0x203C, 0x0000, 0x000C, 0xABFE);

extern pascal gxPaperType GXGetNewPaperType(gxJob aJob, short resID)
 FOURWORDINLINE(0x203C, 0x0000, 0x000D, 0xABFE);

extern pascal long GXCountJobPaperTypes(gxJob aJob, Boolean forFormatDevice)
 FOURWORDINLINE(0x203C, 0x0000, 0x0042, 0xABFE);

extern pascal gxPaperType GXGetJobPaperType(gxJob aJob, long whichPaperType, Boolean forFormatDevice, gxPaperType aPaperType)
 FOURWORDINLINE(0x203C, 0x0000, 0x0043, 0xABFE);

extern pascal void GXForEachJobPaperTypeDo(gxJob aJob, GXPaperTypeUPP aProc, void *refCon, Boolean forFormattingPrinter)
 FOURWORDINLINE(0x203C, 0x0000, 0x0044, 0xABFE);

extern pascal gxPaperType GXCopyPaperType(gxPaperType srcPaperType, gxPaperType dstPaperType)
 FOURWORDINLINE(0x203C, 0x0000, 0x0045, 0xABFE);

extern pascal void GXGetPaperTypeName(gxPaperType aPaperType, Str31 papertypeName)
 FOURWORDINLINE(0x203C, 0x0000, 0x0046, 0xABFE);

extern pascal void GXGetPaperTypeDimensions(gxPaperType aPaperType, gxRectangle *pageSize, gxRectangle *paperSize)
 FOURWORDINLINE(0x203C, 0x0000, 0x0047, 0xABFE);

extern pascal gxJob GXGetPaperTypeJob(gxPaperType aPaperType)
 FOURWORDINLINE(0x203C, 0x0000, 0x0048, 0xABFE);

extern pascal Collection GXGetPaperTypeCollection(gxPaperType aPaperType)
 FOURWORDINLINE(0x203C, 0x0000, 0x0049, 0xABFE);

/*
    Printer Routines
*/
extern pascal gxPrinter GXGetJobFormattingPrinter(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0027, 0xABFE);

extern pascal gxPrinter GXGetJobOutputPrinter(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0028, 0xABFE);

extern pascal gxPrinter GXGetJobPrinter(gxJob aJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x0029, 0xABFE);

extern pascal gxJob GXGetPrinterJob(gxPrinter aPrinter)
 FOURWORDINLINE(0x203C, 0x0000, 0x002A, 0xABFE);

extern pascal void GXForEachPrinterViewDeviceDo(gxPrinter aPrinter, GXViewDeviceUPP aProc, void *refCon)
 FOURWORDINLINE(0x203C, 0x0000, 0x002B, 0xABFE);

extern pascal long GXCountPrinterViewDevices(gxPrinter aPrinter)
 FOURWORDINLINE(0x203C, 0x0000, 0x002C, 0xABFE);

extern pascal gxViewDevice GXGetPrinterViewDevice(gxPrinter aPrinter, long whichViewDevice)
 FOURWORDINLINE(0x203C, 0x0000, 0x002D, 0xABFE);

extern pascal void GXSelectPrinterViewDevice(gxPrinter aPrinter, long whichViewDevice)
 FOURWORDINLINE(0x203C, 0x0000, 0x002E, 0xABFE);

extern pascal void GXGetPrinterName(gxPrinter aPrinter, Str31 printerName)
 FOURWORDINLINE(0x203C, 0x0000, 0x002F, 0xABFE);

extern pascal OSType GXGetPrinterType(gxPrinter aPrinter)
 FOURWORDINLINE(0x203C, 0x0000, 0x0030, 0xABFE);

extern pascal void GXGetPrinterDriverName(gxPrinter aPrinter, Str31 driverName)
 FOURWORDINLINE(0x203C, 0x0000, 0x0031, 0xABFE);

extern pascal OSType GXGetPrinterDriverType(gxPrinter aPrinter)
 FOURWORDINLINE(0x203C, 0x0000, 0x0032, 0xABFE);

/*
    Dialog Routines
*/
extern pascal gxDialogResult GXJobDefaultFormatDialog(gxJob aJob, gxEditMenuRecord *anEditMenuRec)
 FOURWORDINLINE(0x203C, 0x0000, 0x0010, 0xABFE);

extern pascal gxDialogResult GXJobPrintDialog(gxJob aJob, gxEditMenuRecord *anEditMenuRec)
 FOURWORDINLINE(0x203C, 0x0000, 0x0011, 0xABFE);

extern pascal gxDialogResult GXFormatDialog(gxFormat aFormat, gxEditMenuRecord *anEditMenuRec, StringPtr title)
 FOURWORDINLINE(0x203C, 0x0000, 0x0012, 0xABFE);

extern pascal void GXEnableJobScalingPanel(gxJob aJob, Boolean enabled)
 FOURWORDINLINE(0x203C, 0x0000, 0x0040, 0xABFE);

extern pascal void GXGetJobPanelDimensions(gxJob aJob, Rect *panelArea)
 FOURWORDINLINE(0x203C, 0x0000, 0x0041, 0xABFE);

/*
    Spooling Routines
*/
extern pascal void GXGetJobPageRange(gxJob theJob, long *firstPage, long *lastPage)
 FOURWORDINLINE(0x203C, 0x0000, 0x0017, 0xABFE);

extern pascal void GXStartJob(gxJob theJob, StringPtr docName, long pageCount)
 FOURWORDINLINE(0x203C, 0x0000, 0x0018, 0xABFE);

extern pascal void GXPrintPage(gxJob theJob, long pageNumber, gxFormat theFormat, gxShape thePage)
 FOURWORDINLINE(0x203C, 0x0000, 0x0019, 0xABFE);

extern pascal Boolean GXStartPage(gxJob theJob, long pageNumber, gxFormat theFormat, long numViewPorts, gxViewPort *viewPortList)
 FOURWORDINLINE(0x203C, 0x0000, 0x001A, 0xABFE);

extern pascal void GXFinishPage(gxJob theJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x001B, 0xABFE);

extern pascal void GXFinishJob(gxJob theJob)
 FOURWORDINLINE(0x203C, 0x0000, 0x001C, 0xABFE);

/*
    PrintFile Routines
*/
extern pascal gxPrintFile GXOpenPrintFile(gxJob theJob, FSSpecPtr anFSSpec, char permission)
 FOURWORDINLINE(0x203C, 0x0000, 0x004A, 0xABFE);

extern pascal void GXClosePrintFile(gxPrintFile aPrintFile)
 FOURWORDINLINE(0x203C, 0x0000, 0x004B, 0xABFE);

extern pascal gxJob GXGetPrintFileJob(gxPrintFile aPrintFile)
 FOURWORDINLINE(0x203C, 0x0000, 0x004C, 0xABFE);

extern pascal long GXCountPrintFilePages(gxPrintFile aPrintFile)
 FOURWORDINLINE(0x203C, 0x0000, 0x004D, 0xABFE);

extern pascal void GXReadPrintFilePage(gxPrintFile aPrintFile, long pageNumber, long numViewPorts, gxViewPort *viewPortList, gxFormat *pgFormat, gxShape *pgShape)
 FOURWORDINLINE(0x203C, 0x0000, 0x004E, 0xABFE);

extern pascal void GXReplacePrintFilePage(gxPrintFile aPrintFile, long pageNumber, gxFormat aFormat, gxShape aShape)
 FOURWORDINLINE(0x203C, 0x0000, 0x004F, 0xABFE);

extern pascal void GXInsertPrintFilePage(gxPrintFile aPrintFile, long atPageNumber, gxFormat pgFormat, gxShape pgShape)
 FOURWORDINLINE(0x203C, 0x0000, 0x0050, 0xABFE);

extern pascal void GXDeletePrintFilePageRange(gxPrintFile aPrintFile, long fromPageNumber, long toPageNumber)
 FOURWORDINLINE(0x203C, 0x0000, 0x0051, 0xABFE);

extern pascal void GXSavePrintFile(gxPrintFile aPrintFile, FSSpec *anFSSpec)
 FOURWORDINLINE(0x203C, 0x0000, 0x0052, 0xABFE);

/*
    ColorSync Routines
*/
extern pascal long GXFindPrinterProfile(gxPrinter aPrinter, void *searchData, long index, gxColorProfile *returnedProfile)
 FOURWORDINLINE(0x203C, 0x0000, 0x0053, 0xABFE);

extern pascal long GXFindFormatProfile(gxFormat aFormat, void *searchData, long index, gxColorProfile *returnedProfile)
 FOURWORDINLINE(0x203C, 0x0000, 0x0054, 0xABFE);

extern pascal void GXSetPrinterProfile(gxPrinter aPrinter, gxColorProfile oldProfile, gxColorProfile newProfile)
 FOURWORDINLINE(0x203C, 0x0000, 0x0055, 0xABFE);

extern pascal void GXSetFormatProfile(gxFormat aFormat, gxColorProfile oldProfile, gxColorProfile newProfile)
 FOURWORDINLINE(0x203C, 0x0000, 0x0056, 0xABFE);

/*
***********************************************************************
                        Start of old "GXPrintingResEquates.h/a/p" interface file.
                ************************************************************************
*/
/*
    ------------------------------------
                Basic client types
    ------------------------------------
*/

enum {
    gxPrintingManagerType        = 'pmgr',
    gxImagingSystemType            = 'gxis',
    gxPrinterDriverType            = 'pdvr',
    gxPrintingExtensionType        = 'pext',
    gxUnknownPrinterType        = 'none',
    gxAnyPrinterType            = 'univ',
    gxQuickdrawPrinterType        = 'qdrw',
    gxPortableDocPrinterType    = 'gxpd',
    gxRasterPrinterType            = 'rast',
    gxPostscriptPrinterType        = 'post',
    gxVectorPrinterType            = 'vect'
};

/* All pre-defined printing collection items have this ID */

enum {
    gxPrintingTagID                = -28672
};

/*
    ----------------------------------------------------------------------

        Resource types and IDs used by both extension and driver writers

    ----------------------------------------------------------------------
*/
/* Resources in a printer driver or extension must be based off of these IDs */

enum {
    gxPrintingDriverBaseID        = -27648,
    gxPrintingExtensionBaseID    = -27136
};

/*
    Override resources tell the system what messages a driver or extension
        is overriding.  A driver may have a series of these resources.
*/
/* Override resource type for 68k resource-based code:*/

enum {
    gxOverrideType                = 'over'
};

/* Override resource type for PowerPC datafork-based code:*/

enum {
    gxNativeOverrideType        = 'povr'
};

/*
    --------------------------------------------------------------

        Message ID definitions by both extension and driver writers

    ---------------------------------------------------------------
*/
/* Identifiers for universal message overrides. */

enum {
    gxInitializeMsg                = 0,
    gxShutDownMsg                = 1,
    gxJobIdleMsg                = 2,
    gxJobStatusMsg                = 3,
    gxPrintingEventMsg            = 4,
    gxJobDefaultFormatDialogMsg    = 5,
    gxFormatDialogMsg            = 6,
    gxJobPrintDialogMsg            = 7,
    gxFilterPanelEventMsg        = 8,
    gxHandlePanelEventMsg        = 9,
    gxParsePageRangeMsg            = 10,
    gxDefaultJobMsg                = 11,
    gxDefaultFormatMsg            = 12,
    gxDefaultPaperTypeMsg        = 13,
    gxDefaultPrinterMsg            = 14,
    gxCreateSpoolFileMsg        = 15,
    gxSpoolPageMsg                = 16,
    gxSpoolDataMsg                = 17,
    gxSpoolResourceMsg            = 18,
    gxCompleteSpoolFileMsg        = 19,
    gxCountPagesMsg                = 20,
    gxDespoolPageMsg            = 21,
    gxDespoolDataMsg            = 22,
    gxDespoolResourceMsg        = 23,
    gxCloseSpoolFileMsg            = 24,
    gxStartJobMsg                = 25,
    gxFinishJobMsg                = 26,
    gxStartPageMsg                = 27,
    gxFinishPageMsg                = 28,
    gxPrintPageMsg                = 29,
    gxSetupImageDataMsg            = 30,
    gxImageJobMsg                = 31,
    gxImageDocumentMsg            = 32,
    gxImagePageMsg                = 33,
    gxRenderPageMsg                = 34,
    gxCreateImageFileMsg        = 35,
    gxOpenConnectionMsg            = 36,
    gxCloseConnectionMsg        = 37,
    gxStartSendPageMsg            = 38,
    gxFinishSendPageMsg            = 39,
    gxWriteDataMsg                = 40,
    gxBufferDataMsg                = 41,
    gxDumpBufferMsg                = 42,
    gxFreeBufferMsg                = 43,
    gxCheckStatusMsg            = 44,
    gxGetDeviceStatusMsg        = 45,
    gxFetchTaggedDataMsg        = 46,
    gxGetDTPMenuListMsg            = 47,
    gxDTPMenuSelectMsg            = 48,
    gxHandleAlertFilterMsg        = 49,
    gxJobFormatModeQueryMsg        = 50,
    gxWriteStatusToDTPWindowMsg    = 51,
    gxInitializeStatusAlertMsg    = 52,
    gxHandleAlertStatusMsg        = 53,
    gxHandleAlertEventMsg        = 54,
    gxCleanupStartJobMsg        = 55,
    gxCleanupStartPageMsg        = 56,
    gxCleanupOpenConnectionMsg    = 57,
    gxCleanupStartSendPageMsg    = 58,
    gxDefaultDesktopPrinterMsg    = 59,
    gxCaptureOutputDeviceMsg    = 60,
    gxOpenConnectionRetryMsg    = 61,
    gxExamineSpoolFileMsg        = 62,
    gxFinishSendPlaneMsg        = 63,
    gxDoesPaperFitMsg            = 64,
    gxChooserMessageMsg            = 65,
    gxFindPrinterProfileMsg        = 66,
    gxFindFormatProfileMsg        = 67,
    gxSetPrinterProfileMsg        = 68,
    gxSetFormatProfileMsg        = 69,
    gxHandleAltDestinationMsg    = 70,
    gxSetupPageImageDataMsg        = 71
};

/* Identifiers for Quickdraw message overrides. */

enum {
    gxPrOpenDocMsg                = 0,
    gxPrCloseDocMsg                = 1,
    gxPrOpenPageMsg                = 2,
    gxPrClosePageMsg            = 3,
    gxPrintDefaultMsg            = 4,
    gxPrStlDialogMsg            = 5,
    gxPrJobDialogMsg            = 6,
    gxPrStlInitMsg                = 7,
    gxPrJobInitMsg                = 8,
    gxPrDlgMainMsg                = 9,
    gxPrValidateMsg                = 10,
    gxPrJobMergeMsg                = 11,
    gxPrGeneralMsg                = 12,
    gxConvertPrintRecordToMsg    = 13,
    gxConvertPrintRecordFromMsg    = 14,
    gxPrintRecordToJobMsg        = 15
};

/* Identifiers for raster imaging message overrides. */

enum {
    gxRasterDataInMsg            = 0,
    gxRasterLineFeedMsg            = 1,
    gxRasterPackageBitmapMsg    = 2
};

/* Identifiers for PostScript imaging message overrides. */

enum {
    gxPostscriptQueryPrinterMsg    = 0,
    gxPostscriptInitializePrinterMsg = 1,
    gxPostscriptResetPrinterMsg    = 2,
    gxPostscriptExitServerMsg    = 3,
    gxPostscriptGetStatusTextMsg = 4,
    gxPostscriptGetPrinterTextMsg = 5,
    gxPostscriptScanStatusTextMsg = 6,
    gxPostscriptScanPrinterTextMsg = 7,
    gxPostscriptGetDocumentProcSetListMsg = 8,
    gxPostscriptDownloadProcSetListMsg = 9,
    gxPostscriptGetPrinterGlyphsInformationMsg = 10,
    gxPostscriptStreamFontMsg    = 11,
    gxPostscriptDoDocumentHeaderMsg = 12,
    gxPostscriptDoDocumentSetUpMsg = 13,
    gxPostscriptDoDocumentTrailerMsg = 14,
    gxPostscriptDoPageSetUpMsg    = 15,
    gxPostscriptSelectPaperTypeMsg = 16,
    gxPostscriptDoPageTrailerMsg = 17,
    gxPostscriptEjectPageMsg    = 18,
    gxPostscriptProcessShapeMsg    = 19,
    gxPostScriptEjectPendingPageMsg = 20
};

/* Identifiers for Vector imaging message overrides. */

enum {
    gxVectorPackageDataMsg        = 0,
    gxVectorLoadPensMsg            = 1,
    gxVectorVectorizeShapeMsg    = 2
};

/* Dialog related resource types */

enum {
    gxPrintingAlertType            = 'plrt',
    gxStatusType                = 'stat',
    gxExtendedDITLType            = 'xdtl',
    gxPrintPanelType            = 'ppnl',
    gxCollectionType            = 'cltn'
};

/* Communication resource types */
/*
    The looker resource is used by the Chooser PACK to determine what kind
    of communications this driver supports. (In order to generate/handle the
    pop-up menu for "Connect via:".

    The looker resource is also used by PrinterShare to determine the AppleTalk NBP Type
    for servers created for this driver.
*/

enum {
    gxLookerType                = 'look',
    gxLookerID                    = -4096
};

/* The communications method and private data used to connect to the printer */

enum {
    gxDeviceCommunicationsType    = 'comm'
};

/*
    -------------------------------------------------

    Resource types and IDs used by extension writers

    -------------------------------------------------
*/

enum {
    gxExtensionUniversalOverrideID = gxPrintingExtensionBaseID
};


enum {
    gxExtensionImagingOverrideSelectorID = gxPrintingExtensionBaseID
};


enum {
    gxExtensionScopeType        = 'scop',
    gxDriverScopeID                = gxPrintingExtensionBaseID,
    gxPrinterScopeID            = gxPrintingExtensionBaseID + 1,
    gxPrinterExceptionScopeID    = gxPrintingExtensionBaseID + 2
};


enum {
    gxExtensionLoadType            = 'load',
    gxExtensionLoadID            = gxPrintingExtensionBaseID
};


enum {
    gxExtensionLoadFirst        = 0x00000100,
    gxExtensionLoadAnywhere        = 0x7FFFFFFF,
    gxExtensionLoadLast            = 0xFFFFFF00
};


enum {
    gxExtensionOptimizationType    = 'eopt',
    gxExtensionOptimizationID    = gxPrintingExtensionBaseID
};

/*
    -----------------------------------------------

    Resource types and IDs used by driver writers

    -----------------------------------------------
*/

enum {
    gxDriverUniversalOverrideID    = gxPrintingDriverBaseID,
    gxDriverImagingOverrideID    = gxPrintingDriverBaseID + 1,
    gxDriverCompatibilityOverrideID = gxPrintingDriverBaseID + 2
};


enum {
    gxDriverFileFormatType        = 'pfil',
    gxDriverFileFormatID        = gxPrintingDriverBaseID
};


enum {
    gxDestinationAdditionType    = 'dsta',
    gxDestinationAdditionID        = gxPrintingDriverBaseID
};

/* IMAGING RESOURCES */
/*
    The imaging system resource specifies which imaging system a printer
        driver wishes to use.
*/

enum {
    gxImagingSystemSelectorType    = 'isys',
    gxImagingSystemSelectorID    = gxPrintingDriverBaseID
};

/* 'exft' resource ID -- exclude font list */

enum {
    kExcludeFontListType        = 'exft',
    kExcludeFontListID            = gxPrintingDriverBaseID
};

/* Resource for type for color matching */

enum {
    gxColorMatchingDataType        = 'prof',
    gxColorMatchingDataID        = gxPrintingDriverBaseID
};

/* Resource type and id for the tray count */

enum {
    gxTrayCountDataType            = 'tray',
    gxTrayCountDataID            = gxPrintingDriverBaseID
};

/* Resource type for the tray names */

enum {
    gxTrayNameDataType            = 'tryn'
};

/* Resource type for manual feed preferences, stored in DTP. */

enum {
    gxManualFeedAlertPrefsType    = 'mfpr',
    gxManualFeedAlertPrefsID    = gxPrintingDriverBaseID
};

/* Resource type for desktop printer output characteristics, stored in DTP. */

enum {
    gxDriverOutputType            = 'outp',
    gxDriverOutputTypeID        = 1
};

/* IO Resources */
/* Resource type and ID for default IO and buffering resources */

enum {
    gxUniversalIOPrefsType        = 'iobm',
    gxUniversalIOPrefsID        = gxPrintingDriverBaseID
};

/*
    Resource types and IDs for default implementation of CaptureOutputDevice.
        The default implementation of CaptureOutputDevice only handles PAP devices
*/

enum {
    gxCaptureType                = 'cpts',
    gxCaptureStringID            = gxPrintingDriverBaseID,
    gxReleaseStringID            = gxPrintingDriverBaseID + 1,
    gxUncapturedAppleTalkType    = gxPrintingDriverBaseID + 2,
    gxCapturedAppleTalkType        = gxPrintingDriverBaseID + 3
};

/* Resource type and ID for custom halftone matrix */

enum {
    gxCustomMatrixType            = 'dmat',
    gxCustomMatrixID            = gxPrintingDriverBaseID
};

/* Resource type and ID for raster driver rendering preferences */

enum {
    gxRasterPrefsType            = 'rdip',
    gxRasterPrefsID                = gxPrintingDriverBaseID
};

/* Resource type for specifiying a colorset */

enum {
    gxColorSetResType            = 'crst'
};

/* Resource type and ID for raster driver packaging preferences */

enum {
    gxRasterPackType            = 'rpck',
    gxRasterPackID                = gxPrintingDriverBaseID
};

/* Resource type and ID for raster driver packaging options */

enum {
    gxRasterNumNone                = 0,                            /* Number isn't output at all */
    gxRasterNumDirect            = 1,                            /* Lowest minWidth bytes as data */
    gxRasterNumToASCII            = 2                                /* minWidth ASCII characters */
};


enum {
    gxRasterPackOptionsType        = 'ropt',
    gxRasterPackOptionsID        = gxPrintingDriverBaseID
};

/* Resource type for the PostScript imaging system procedure set control resource */

enum {
    gxPostscriptProcSetControlType = 'prec'
};

/* Resource type for the PostScript imaging system printer font resource */

enum {
    gxPostscriptPrinterFontType    = 'pfnt'
};

/* Resource type and ID for the PostScript imaging system imaging preferences */

enum {
    gxPostscriptPrefsType        = 'pdip',
    gxPostscriptPrefsID            = gxPrintingDriverBaseID
};

/* Resource type and ID for the PostScript imaging system default scanning code */

enum {
    gxPostscriptScanningType    = 'scan',
    gxPostscriptScanningID        = gxPrintingDriverBaseID
};

/* Old Application Support Resources */

enum {
    gxCustType                    = 'cust',
    gxCustID                    = -8192
};


enum {
    gxReslType                    = 'resl',
    gxReslID                    = -8192
};


enum {
    gxDiscreteResolution        = 0
};


enum {
    gxStlDialogResID            = -8192
};


enum {
    gxJobDialogResID            = -8191
};


enum {
    gxScaleTableType            = 'stab',
    gxDITLControlType            = 'dctl'
};

/*
    The default implementation of gxPrintDefault loads and
    PrValidates a print record stored in the following driver resource.
*/

enum {
    gxPrintRecordType            = 'PREC',
    gxDefaultPrintRecordID        = 0
};

/*
    -----------------------------------------------

    Resource types and IDs used in papertype files

    -----------------------------------------------
*/
/* Resource type and ID for driver papertypes placed in individual files */

enum {
    gxSignatureType                = 'sig ',
    gxPapertypeSignatureID        = 0
};

/* Papertype creator types */

enum {
    gxDrvrPaperType                = 'drpt',
    gxSysPaperType                = 'sypt',                        /* System paper type creator */
    gxUserPaperType                = 'uspt',                        /* User paper type creator */
                                                                /* Driver creator types == driver file's creator value */
    gxPaperTypeType                = 'ptyp'
};

/*
********************************************************************
                    Start of old "GXPrintingMessages.h/a/p" interface file.
            *********************************************************************
*/
/*
 ------------------------------------------------------------------------------

                                    Constants and Types

--------------------------------------------------------------------------------
*/
/*

    ABSTRACT DATA TYPES

*/
typedef struct OpaquegxSpoolFile* gxSpoolFile;
/*

    DIALOG PANEL CONSTANTS AND TYPES

*/
typedef long gxPanelEvent;
/* Dialog panel event equates */

enum {
    gxPanelNoEvt                = 0L,
    gxPanelOpenEvt                = 1L,                            /* Initialize and draw */
    gxPanelCloseEvt                = 2L,                            /* Your panel is going away (panel switchL, confirm or cancel) */
    gxPanelHitEvt                = 3L,                            /* There's a hit in your panel */
    gxPanelActivateEvt            = 4L,                            /* The dialog window has just been activated */
    gxPanelDeactivateEvt        = 5L,                            /* The dialog window is about to be deactivated */
    gxPanelIconFocusEvt            = 6L,                            /* The focus changes from the panel to the icon list */
    gxPanelPanelFocusEvt        = 7L,                            /* The focus changes from the icon list to the panel */
    gxPanelFilterEvt            = 8L,                            /* Every event is filtered */
    gxPanelCancelEvt            = 9L,                            /* The user has cancelled the dialog */
    gxPanelConfirmEvt            = 10L,                            /* The user has confirmed the dialog */
    gxPanelDialogEvt            = 11L,                            /* Event to be handle by dialoghandler */
    gxPanelOtherEvt                = 12L,                            /* osEvts, etc. */
    gxPanelUserWillConfirmEvt    = 13L                            /* User has selected confirm, time to parse panel interdependencies */
};

/* Constants for panel responses to dialog handler calls */
typedef long gxPanelResult;

enum {
    gxPanelNoResult                = 0,
    gxPanelCancelConfirmation    = 1                                /* Only valid from panelUserWillConfirmEvt - used to keep the dialog from going away */
};

/* Panel event info record for FilterPanelEvent and HandlePanelEvent messages */
struct gxPanelInfoRecord {
    gxPanelEvent                     panelEvt;                    /* Why we were called */
    short                             panelResId;                    /* 'ppnl' resource ID of current panel */
    DialogPtr                         pDlg;                        /* Pointer to dialog */
    EventRecord *                    theEvent;                    /* Pointer to event */
    short                             itemHit;                    /* Actual item number as Dialog Mgr thinks */
    short                             itemCount;                    /* Number of items before your items */
    short                             evtAction;                    /* Once this event is processed, the action that will result */
                                                                /* (evtAction is only meaningful during filtering) */
    short                             errorStringId;                /* STR ID of string to put in error alert (0 means no string) */
    gxFormat                         theFormat;                    /* The current format (only meaningful in a format dialog) */
    void *                            refCon;                        /* refCon passed in PanelSetupRecord */
};
typedef struct gxPanelInfoRecord gxPanelInfoRecord;

/* Constants for the evtAction field in PanelInfoRecord */

enum {
    gxOtherAction                = 0,                            /* Current item will not change */
    gxClosePanelAction            = 1,                            /* Panel will be closed */
    gxCancelDialogAction        = 2,                            /* Dialog will be cancelled */
    gxConfirmDialogAction        = 3                                /* Dialog will be confirmed */
};

/* Constants for the panelKind field in gxPanelSetupRecord */
typedef long gxPrintingPanelKind;
/* The gxPanelSetupInfo structure is passed to GXSetupDialogPanel */
struct gxPanelSetupRecord {
    gxPrintingPanelKind             panelKind;
    short                             panelResId;
    short                             resourceRefNum;
    void *                            refCon;
};
typedef struct gxPanelSetupRecord gxPanelSetupRecord;


enum {
    gxApplicationPanel            = 0L,
    gxExtensionPanel            = 1L,
    gxDriverPanel                = 2L
};

/* Constants returned by gxParsePageRange message */
typedef long gxParsePageRangeResult;

enum {
    gxRangeNotParsed            = 0L,                            /* Default initial value */
    gxRangeParsed                = 1L,                            /* Range has been parsed */
    gxRangeBadFromValue            = 2L,                            /* From value is bad */
    gxRangeBadToValue            = 3L                            /* To value is bad */
};

/*

    STATUS-RELATED CONSTANTS AND TYPES

*/
/* Structure for status messages */
struct gxStatusRecord {
    unsigned short                     statusType;                    /* One of the ids listed above (nonFatalError, etc. ) */
    unsigned short                     statusId;                    /* Specific status (out of paper, etc.) */
    unsigned short                     statusAlertId;                /*    Printing alert ID (if any) for status */
    gxOwnerSignature                 statusOwner;                /* Creator type of status owner */
    short                             statResId;                    /* ID for 'stat' resource */
    short                             statResIndex;                /* Index into 'stat' resource for this status */
    short                             dialogResult;                /* ID of button string selected on dismissal of printing alert */
    unsigned short                     bufferLen;                    /* Number of bytes in status buffer - total record size must be <= 512 */
    char                             statusBuffer[1];            /* User response from alert */
};
typedef struct gxStatusRecord gxStatusRecord;

/* Constants for statusType field of gxStatusRecord */

enum {
    gxNonFatalError                = 1,                            /* An error occurred, but the job can continue */
    gxFatalError                = 2,                            /* A fatal error occurred-- halt job */
    gxPrinterReady                = 3,                            /* Tells QDGX to leave alert mode */
    gxUserAttention                = 4,                            /* Signals initiation of a modal alert */
    gxUserAlert                    = 5,                            /* Signals initiation of a moveable modal alert */
    gxPageTransmission            = 6,                            /* Signals page sent to printer, increments page count in strings to user */
    gxOpenConnectionStatus        = 7,                            /* Signals QDGX to begin animation on printer icon */
    gxInformationalStatus        = 8,                            /* Default status type, no side effects */
    gxSpoolingPageStatus        = 9,                            /* Signals page spooled, increments page count in spooling dialog */
    gxEndStatus                    = 10,                            /* Signals end of spooling */
    gxPercentageStatus            = 11                            /* Signals QDGX as to the amount of the job which is currently complete */
};

/* Structure for gxWriteStatusToDTPWindow message */
struct gxDisplayRecord {
    Boolean                         useText;                    /* Use text as opposed to a picture */
    char                             padByte;
    Handle                             hPicture;                    /* if !useText, the picture handle */
    Str255                             theText;                    /* if useText, the text */
};
typedef struct gxDisplayRecord gxDisplayRecord;

/*-----------------------------------------------*/
/* paper mapping-related constants and types...  */
/*-----------------------------------------------*/
typedef long gxTrayMapping;

enum {
    gxDefaultTrayMapping        = 0L,
    gxConfiguredTrayMapping        = 1L
};

/*
 ------------------------------------------------------------------------------

                API Functions callable only from within message overrides

--------------------------------------------------------------------------------
*/
#define GXPRINTINGDISPATCH(segID, selector) {0x203C, 0x0001, 0, 0x223C, (segID & 0x0FFF), selector << 2, 0xABFE}
/*
    Message Sending API Routines
*/
#if !GENERATINGPOWERPC
extern OSErr GXPrintingDispatch(long selector, ...)
 SIXWORDINLINE(0x221F, 0x203C, 0x0001, 0x0000, 0xABFE, 0x598F);

#endif
/*

    How to use the GXPRINTINGDISPATCH macro...

    If your driver or extension is large, you may want to segment it
    across smaller boundaries than is permitted by the messaging system.
    Without using the Printing Manager's segmentation manager directly,
    the smallest segment you can create consists of the code to override
    a single message.  If you are overriding workhorse messages such as
    RenderPage, you may want to divide up the work among many functions
    distributed across several segments.  Here's how...

    The Printing Manager segment scheme involves the construction of a
    single 32-bit dispatch selector, which contains all the information
    necessary for the dispatcher to find a single routine.  It contains the
    segment's resource ID, and the offset within the segment which contains
    the start of the routine.  The GXPRINTINGDISPATCH macro will construct the
    dispatch selector for you, as well as the code to do the dispatch.

    Usually, it is convenient to start your segment with a long aligned jump table,
    beginning after the 4 byte header required by the Printing Manager.  The
    macro assumes this is the case and takes a 1-based routine selector from
    which it conmstructs the offset.

    For example, if your code is in resource 'pdvr' (print driver), ID=2
    at offset=12 (third routine in segment), you would declare your
    routine as follows:

    OSErr MyRenderingRoutine (long param1, Ptr param2)
        = GXPRINTINGDISPATCH(2, 3);

    Remember, ALL segment dispatches must return OSErr.  If your routine
    does not generate errors, you must still declare it to return OSErr
    and have the routine itself return noErr.

    An alternative way to call across segments is to call the GXPrintingDispatch
    function directly.  You must construct the 32-bit selector yourself and pass
    it as the first parameter.  This is usually not preferable since you don't get
    type-checking unless you declare a prototype as shown above, and your code
    isn't as easy to read.

    So given the above prototype, there are two ways to call the function:

        anErr = MyRenderingRoutine(p1, p2);            // Free type checking!

    or:

        #define kMyRenderRoutineSelector 0x0002000C
        anErr = GXPrintingDispatch(kMyRenderRoutineSelector, p1, p2);        // No type-checking!


    Both have the same effect.

*/
extern gxJob GXGetJob(void )
 FOURWORDINLINE(0x203C, 0x0001, 0x0001, 0xABFE);

extern short GXGetMessageHandlerResFile(void )
 FOURWORDINLINE(0x203C, 0x0001, 0x0002, 0xABFE);

extern Boolean GXSpoolingAborted(void )
 FOURWORDINLINE(0x203C, 0x0001, 0x0003, 0xABFE);

extern OSErr GXJobIdle(void )
 FOURWORDINLINE(0x203C, 0x0001, 0x0004, 0xABFE);

extern OSErr GXReportStatus(long statusID, unsigned long statusIndex)
 FOURWORDINLINE(0x203C, 0x0001, 0x0005, 0xABFE);

extern OSErr GXAlertTheUser(gxStatusRecord *statusRec)
 FOURWORDINLINE(0x203C, 0x0001, 0x0006, 0xABFE);

extern OSErr GXSetupDialogPanel(gxPanelSetupRecord *panelRec)
 FOURWORDINLINE(0x203C, 0x0001, 0x0007, 0xABFE);

extern OSErr GXCountTrays(gxTrayIndex *numTrays)
 FOURWORDINLINE(0x203C, 0x0001, 0x0008, 0xABFE);

extern OSErr GXGetTrayName(gxTrayIndex trayNumber, Str31 trayName)
 FOURWORDINLINE(0x203C, 0x0001, 0x0009, 0xABFE);

extern OSErr GXSetTrayPaperType(gxTrayIndex whichTray, gxPaperType aPapertype)
 FOURWORDINLINE(0x203C, 0x0001, 0x000A, 0xABFE);

extern OSErr GXGetTrayPaperType(gxTrayIndex whichTray, gxPaperType aPapertype)
 FOURWORDINLINE(0x203C, 0x0001, 0x000B, 0xABFE);

extern OSErr GXGetTrayMapping(gxTrayMapping *trayMapping)
 FOURWORDINLINE(0x203C, 0x0001, 0x000C, 0xABFE);

extern void GXCleanupStartJob(void )
 FOURWORDINLINE(0x203C, 0x0001, 0x000D, 0xABFE);

extern void GXCleanupStartPage(void )
 FOURWORDINLINE(0x203C, 0x0001, 0x000E, 0xABFE);

extern void GXCleanupOpenConnection(void )
 FOURWORDINLINE(0x203C, 0x0001, 0x000F, 0xABFE);

extern void GXCleanupStartSendPage(void )
 FOURWORDINLINE(0x203C, 0x0001, 0x0010, 0xABFE);

/*
 ------------------------------------------------------------------------------

                    Constants and types for Universal Printing Messages

--------------------------------------------------------------------------------
*/
/* Options for gxCreateSpoolFile message */

enum {
    gxNoCreateOptions            = 0x00000000,                    /* Just create the file */
    gxInhibitAlias                = 0x00000001,                    /* Do not create an alias in the PMD folder */
    gxInhibitUniqueName            = 0x00000002,                    /* Do not append to the filename to make it unique */
    gxResolveBitmapAlias        = 0x00000004                    /* Resolve bitmap aliases and duplicate data in file */
};

/* Options for gxCloseSpoolFile message */

enum {
    gxNoCloseOptions            = 0x00000000,                    /* Just close the file */
    gxDeleteOnClose                = 0x00000001,                    /* Delete the file rather than closing it */
    gxUpdateJobData                = 0x00000002,                    /* Write current job information into file prior to closing */
    gxMakeRemoteFile            = 0x00000004                    /* Mark job as a remote file */
};

/* Options for gxCreateImageFile message */

enum {
    gxNoImageFile                = 0x00000000,                    /* Don't create image file */
    gxMakeImageFile                = 0x00000001,                    /* Create an image file */
    gxEachPlane                    = 0x00000002,                    /* Only save up planes before rewinding */
    gxEachPage                    = 0x00000004,                    /* Save up entire pages before rewinding */
    gxEntireFile                = gxEachPlane + gxEachPage        /* Save up the entire file before rewinding */
};

/* Options for gxBufferData message */

enum {
    gxNoBufferOptions            = 0x00000000,
    gxMakeBufferHex                = 0x00000001,
    gxDontSplitBuffer            = 0x00000002
};

/* Structure for gxDumpBuffer and gxFreeBuffer messages */
struct gxPrintingBuffer {
    long                             size;                        /* Size of buffer in bytes */
    long                             userData;                    /* Client assigned id for the buffer */
    char                             data[1];                    /* Array of size bytes */
};
typedef struct gxPrintingBuffer gxPrintingBuffer;

/* Structure for gxRenderPage message */
struct gxPageInfoRecord {
    long                             docPageNum;                    /* Number of page being printed */
    long                             copyNum;                    /* Copy number being printed */
    Boolean                         formatChanged;                /* True if format changed from last page */
    Boolean                         pageChanged;                /* True if page contents changed from last page */
    long                             internalUse;                /* Private */
};
typedef struct gxPageInfoRecord gxPageInfoRecord;

/*
 ------------------------------------------------------------------------------

                                Universal Printing Messages

--------------------------------------------------------------------------------
*/
typedef OSErr (*GXJobIdleProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXJobIdleUPP;
#else
typedef GXJobIdleProcPtr GXJobIdleUPP;
#endif

enum {
    uppGXJobIdleProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
};

#if GENERATINGCFM
#define NewGXJobIdleProc(userRoutine)        \
        (GXJobIdleUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobIdleProcInfo, GetCurrentArchitecture())
#else
#define NewGXJobIdleProc(userRoutine)        \
        ((GXJobIdleUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXJobIdleProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobIdleProcInfo)
#else
#define CallGXJobIdleProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXJobIdle() SendMessage(0x00000002)
#define Forward_GXJobIdle() ForwardThisMessage((void *) (0))
typedef OSErr (*GXJobStatusProcPtr)(gxStatusRecord *pStatus);

#if GENERATINGCFM
typedef UniversalProcPtr GXJobStatusUPP;
#else
typedef GXJobStatusProcPtr GXJobStatusUPP;
#endif

enum {
    uppGXJobStatusProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord *)))
};

#if GENERATINGCFM
#define NewGXJobStatusProc(userRoutine)        \
        (GXJobStatusUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobStatusProcInfo, GetCurrentArchitecture())
#else
#define NewGXJobStatusProc(userRoutine)        \
        ((GXJobStatusUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXJobStatusProc(userRoutine, pStatus)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobStatusProcInfo, (pStatus))
#else
#define CallGXJobStatusProc(userRoutine, pStatus)        \
        (*(userRoutine))((pStatus))
#endif
#define Send_GXJobStatus(pStatus) \
          SendMessage(0x00000003, pStatus)

#define Forward_GXJobStatus(pStatus) \
          ForwardThisMessage((void *) (pStatus))
typedef OSErr (*GXPrintingEventProcPtr)(EventRecord *evtRecord, Boolean filterEvent);

#if GENERATINGCFM
typedef UniversalProcPtr GXPrintingEventUPP;
#else
typedef GXPrintingEventProcPtr GXPrintingEventUPP;
#endif

enum {
    uppGXPrintingEventProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(EventRecord *)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Boolean)))
};

#if GENERATINGCFM
#define NewGXPrintingEventProc(userRoutine)        \
        (GXPrintingEventUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXPrintingEventProcInfo, GetCurrentArchitecture())
#else
#define NewGXPrintingEventProc(userRoutine)        \
        ((GXPrintingEventUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXPrintingEventProc(userRoutine, evtRecord, filterEvent)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXPrintingEventProcInfo, (evtRecord), (filterEvent))
#else
#define CallGXPrintingEventProc(userRoutine, evtRecord, filterEvent)        \
        (*(userRoutine))((evtRecord), (filterEvent))
#endif
#define Send_GXPrintingEvent(evtRecord, filterEvent) \
          SendMessage(0x00000004, evtRecord, filterEvent)

#define Forward_GXPrintingEvent(evtRecord, filterEvent) \
          ForwardThisMessage((void *) (evtRecord), (void *) (filterEvent))
typedef OSErr (*GXJobDefaultFormatDialogProcPtr)(gxDialogResult *dlgResult);

#if GENERATINGCFM
typedef UniversalProcPtr GXJobDefaultFormatDialogUPP;
#else
typedef GXJobDefaultFormatDialogProcPtr GXJobDefaultFormatDialogUPP;
#endif

enum {
    uppGXJobDefaultFormatDialogProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxDialogResult *)))
};

#if GENERATINGCFM
#define NewGXJobDefaultFormatDialogProc(userRoutine)        \
        (GXJobDefaultFormatDialogUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobDefaultFormatDialogProcInfo, GetCurrentArchitecture())
#else
#define NewGXJobDefaultFormatDialogProc(userRoutine)        \
        ((GXJobDefaultFormatDialogUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXJobDefaultFormatDialogProc(userRoutine, dlgResult)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobDefaultFormatDialogProcInfo, (dlgResult))
#else
#define CallGXJobDefaultFormatDialogProc(userRoutine, dlgResult)        \
        (*(userRoutine))((dlgResult))
#endif
#define Send_GXJobDefaultFormatDialog(dlgResult) \
          SendMessage(0x00000005, dlgResult)

#define Forward_GXJobDefaultFormatDialog(dlgResult) \
          ForwardThisMessage((void *) (dlgResult))
typedef OSErr (*GXFormatDialogProcPtr)(gxFormat theFormat, StringPtr title, gxDialogResult *dlgResult);

#if GENERATINGCFM
typedef UniversalProcPtr GXFormatDialogUPP;
#else
typedef GXFormatDialogProcPtr GXFormatDialogUPP;
#endif

enum {
    uppGXFormatDialogProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(StringPtr)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxDialogResult *)))
};

#if GENERATINGCFM
#define NewGXFormatDialogProc(userRoutine)        \
        (GXFormatDialogUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFormatDialogProcInfo, GetCurrentArchitecture())
#else
#define NewGXFormatDialogProc(userRoutine)        \
        ((GXFormatDialogUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFormatDialogProc(userRoutine, theFormat, title, dlgResult)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFormatDialogProcInfo, (theFormat), (title), (dlgResult))
#else
#define CallGXFormatDialogProc(userRoutine, theFormat, title, dlgResult)        \
        (*(userRoutine))((theFormat), (title), (dlgResult))
#endif
#define Send_GXFormatDialog(theFormat, title, dlgResult) \
          SendMessage(0x00000006, theFormat, title, dlgResult)

#define Forward_GXFormatDialog(theFormat, title, dlgResult) \
          ForwardThisMessage((void *) (theFormat),(void *) (title),(void *) (dlgResult))
typedef OSErr (*GXJobPrintDialogProcPtr)(gxDialogResult *dlgResult);

#if GENERATINGCFM
typedef UniversalProcPtr GXJobPrintDialogUPP;
#else
typedef GXJobPrintDialogProcPtr GXJobPrintDialogUPP;
#endif

enum {
    uppGXJobPrintDialogProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxDialogResult *)))
};

#if GENERATINGCFM
#define NewGXJobPrintDialogProc(userRoutine)        \
        (GXJobPrintDialogUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobPrintDialogProcInfo, GetCurrentArchitecture())
#else
#define NewGXJobPrintDialogProc(userRoutine)        \
        ((GXJobPrintDialogUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXJobPrintDialogProc(userRoutine, dlgResult)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobPrintDialogProcInfo, (dlgResult))
#else
#define CallGXJobPrintDialogProc(userRoutine, dlgResult)        \
        (*(userRoutine))((dlgResult))
#endif
#define Send_GXJobPrintDialog(dlgResult) \
          SendMessage(0x00000007, dlgResult)

#define Forward_GXJobPrintDialog(dlgResult) \
          ForwardThisMessage((void *) (dlgResult))
typedef OSErr (*GXFilterPanelEventProcPtr)(gxPanelInfoRecord *pHitInfo, Boolean *returnImmed);

#if GENERATINGCFM
typedef UniversalProcPtr GXFilterPanelEventUPP;
#else
typedef GXFilterPanelEventProcPtr GXFilterPanelEventUPP;
#endif

enum {
    uppGXFilterPanelEventProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPanelInfoRecord *)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Boolean *)))
};

#if GENERATINGCFM
#define NewGXFilterPanelEventProc(userRoutine)        \
        (GXFilterPanelEventUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFilterPanelEventProcInfo, GetCurrentArchitecture())
#else
#define NewGXFilterPanelEventProc(userRoutine)        \
        ((GXFilterPanelEventUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFilterPanelEventProc(userRoutine, pHitInfo, returnImmed)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFilterPanelEventProcInfo, (pHitInfo), (returnImmed))
#else
#define CallGXFilterPanelEventProc(userRoutine, pHitInfo, returnImmed)        \
        (*(userRoutine))((pHitInfo), (returnImmed))
#endif
#define Send_GXFilterPanelEvent(pHitInfo, returnImmed) \
          SendMessage(0x00000008, pHitInfo, returnImmed)
typedef OSErr (*GXHandlePanelEventProcPtr)(gxPanelInfoRecord *pHitInfo, gxPanelResult *panelResponse);

#if GENERATINGCFM
typedef UniversalProcPtr GXHandlePanelEventUPP;
#else
typedef GXHandlePanelEventProcPtr GXHandlePanelEventUPP;
#endif

enum {
    uppGXHandlePanelEventProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPanelInfoRecord *)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxPanelResult *)))
};

#if GENERATINGCFM
#define NewGXHandlePanelEventProc(userRoutine)        \
        (GXHandlePanelEventUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXHandlePanelEventProcInfo, GetCurrentArchitecture())
#else
#define NewGXHandlePanelEventProc(userRoutine)        \
        ((GXHandlePanelEventUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXHandlePanelEventProc(userRoutine, pHitInfo, panelResponse)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXHandlePanelEventProcInfo, (pHitInfo), (panelResponse))
#else
#define CallGXHandlePanelEventProc(userRoutine, pHitInfo, panelResponse)        \
        (*(userRoutine))((pHitInfo), (panelResponse))
#endif
#define Send_GXHandlePanelEvent(pHitInfo, panelResponse) \
          SendMessage(0x00000009, pHitInfo, panelResponse)
typedef OSErr (*GXParsePageRangeProcPtr)(StringPtr fromString, StringPtr toString, gxParsePageRangeResult *result);

#if GENERATINGCFM
typedef UniversalProcPtr GXParsePageRangeUPP;
#else
typedef GXParsePageRangeProcPtr GXParsePageRangeUPP;
#endif

enum {
    uppGXParsePageRangeProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(StringPtr)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(StringPtr)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxParsePageRangeResult *)))
};

#if GENERATINGCFM
#define NewGXParsePageRangeProc(userRoutine)        \
        (GXParsePageRangeUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXParsePageRangeProcInfo, GetCurrentArchitecture())
#else
#define NewGXParsePageRangeProc(userRoutine)        \
        ((GXParsePageRangeUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXParsePageRangeProc(userRoutine, fromString, toString, result)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXParsePageRangeProcInfo, (fromString), (toString), (result))
#else
#define CallGXParsePageRangeProc(userRoutine, fromString, toString, result)        \
        (*(userRoutine))((fromString), (toString), (result))
#endif
#define Send_GXParsePageRange(fromString, toString, result) \
          SendMessage(0x0000000A, fromString, toString, result)

#define Forward_GXParsePageRange(fromString, toString, result) \
          ForwardThisMessage((void *) (fromString), (void *) (toString), (void *) (result))
typedef OSErr (*GXDefaultJobProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXDefaultJobUPP;
#else
typedef GXDefaultJobProcPtr GXDefaultJobUPP;
#endif

enum {
    uppGXDefaultJobProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
};

#if GENERATINGCFM
#define NewGXDefaultJobProc(userRoutine)        \
        (GXDefaultJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultJobProcInfo, GetCurrentArchitecture())
#else
#define NewGXDefaultJobProc(userRoutine)        \
        ((GXDefaultJobUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDefaultJobProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultJobProcInfo)
#else
#define CallGXDefaultJobProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXDefaultJob() SendMessage(0x0000000B)
#define Forward_GXDefaultJob() ForwardThisMessage((void *) (0))
typedef OSErr (*GXDefaultFormatProcPtr)(gxFormat theFormat);

#if GENERATINGCFM
typedef UniversalProcPtr GXDefaultFormatUPP;
#else
typedef GXDefaultFormatProcPtr GXDefaultFormatUPP;
#endif

enum {
    uppGXDefaultFormatProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
};

#if GENERATINGCFM
#define NewGXDefaultFormatProc(userRoutine)        \
        (GXDefaultFormatUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultFormatProcInfo, GetCurrentArchitecture())
#else
#define NewGXDefaultFormatProc(userRoutine)        \
        ((GXDefaultFormatUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDefaultFormatProc(userRoutine, theFormat)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultFormatProcInfo, (theFormat))
#else
#define CallGXDefaultFormatProc(userRoutine, theFormat)        \
        (*(userRoutine))((theFormat))
#endif
#define Send_GXDefaultFormat(theFormat) \
          SendMessage(0x0000000C, theFormat)

#define Forward_GXDefaultFormat(theFormat) \
          ForwardThisMessage((void *) (theFormat))
typedef OSErr (*GXDefaultPaperTypeProcPtr)(gxPaperType thePaperType);

#if GENERATINGCFM
typedef UniversalProcPtr GXDefaultPaperTypeUPP;
#else
typedef GXDefaultPaperTypeProcPtr GXDefaultPaperTypeUPP;
#endif

enum {
    uppGXDefaultPaperTypeProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPaperType)))
};

#if GENERATINGCFM
#define NewGXDefaultPaperTypeProc(userRoutine)        \
        (GXDefaultPaperTypeUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultPaperTypeProcInfo, GetCurrentArchitecture())
#else
#define NewGXDefaultPaperTypeProc(userRoutine)        \
        ((GXDefaultPaperTypeUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDefaultPaperTypeProc(userRoutine, thePaperType)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultPaperTypeProcInfo, (thePaperType))
#else
#define CallGXDefaultPaperTypeProc(userRoutine, thePaperType)        \
        (*(userRoutine))((thePaperType))
#endif
#define Send_GXDefaultPaperType(thePaperType) \
          SendMessage(0x0000000D, thePaperType)

#define Forward_GXDefaultPaperType(thePaperType) \
          ForwardThisMessage((void *) thePaperType)
typedef OSErr (*GXDefaultPrinterProcPtr)(gxPrinter thePrinter);

#if GENERATINGCFM
typedef UniversalProcPtr GXDefaultPrinterUPP;
#else
typedef GXDefaultPrinterProcPtr GXDefaultPrinterUPP;
#endif

enum {
    uppGXDefaultPrinterProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrinter)))
};

#if GENERATINGCFM
#define NewGXDefaultPrinterProc(userRoutine)        \
        (GXDefaultPrinterUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultPrinterProcInfo, GetCurrentArchitecture())
#else
#define NewGXDefaultPrinterProc(userRoutine)        \
        ((GXDefaultPrinterUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDefaultPrinterProc(userRoutine, thePrinter)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultPrinterProcInfo, (thePrinter))
#else
#define CallGXDefaultPrinterProc(userRoutine, thePrinter)        \
        (*(userRoutine))((thePrinter))
#endif
#define Send_GXDefaultPrinter(thePrinter) \
          SendMessage(0x0000000E, thePrinter)

#define Forward_GXDefaultPrinter(thePrinter) \
          ForwardThisMessage((void *) thePrinter)
typedef OSErr (*GXCreateSpoolFileProcPtr)(FSSpecPtr pFileSpec, long createOptions, gxSpoolFile *theSpoolFile);

#if GENERATINGCFM
typedef UniversalProcPtr GXCreateSpoolFileUPP;
#else
typedef GXCreateSpoolFileProcPtr GXCreateSpoolFileUPP;
#endif

enum {
    uppGXCreateSpoolFileProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(FSSpecPtr)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxSpoolFile *)))
};

#if GENERATINGCFM
#define NewGXCreateSpoolFileProc(userRoutine)        \
        (GXCreateSpoolFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCreateSpoolFileProcInfo, GetCurrentArchitecture())
#else
#define NewGXCreateSpoolFileProc(userRoutine)        \
        ((GXCreateSpoolFileUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCreateSpoolFileProc(userRoutine, pFileSpec, createOptions, theSpoolFile)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCreateSpoolFileProcInfo, (pFileSpec), (createOptions), (theSpoolFile))
#else
#define CallGXCreateSpoolFileProc(userRoutine, pFileSpec, createOptions, theSpoolFile)        \
        (*(userRoutine))((pFileSpec), (createOptions), (theSpoolFile))
#endif
#define Send_GXCreateSpoolFile(pFileSpec, createOptions, theSpoolFile) \
          SendMessage(0x0000000F, pFileSpec, createOptions, \
                            theSpoolFile)

#define Forward_GXCreateSpoolFile(pFileSpec, createOptions, theSpoolFile) \
          ForwardThisMessage((void *) pFileSpec, (void *) (createOptions), (void *) theSpoolFile)
typedef OSErr (*GXSpoolPageProcPtr)(gxSpoolFile theSpoolFile, gxFormat theFormat, gxShape thePage);

#if GENERATINGCFM
typedef UniversalProcPtr GXSpoolPageUPP;
#else
typedef GXSpoolPageProcPtr GXSpoolPageUPP;
#endif

enum {
    uppGXSpoolPageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxShape)))
};

#if GENERATINGCFM
#define NewGXSpoolPageProc(userRoutine)        \
        (GXSpoolPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSpoolPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXSpoolPageProc(userRoutine)        \
        ((GXSpoolPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXSpoolPageProc(userRoutine, theSpoolFile, theFormat, thePage)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSpoolPageProcInfo, (theSpoolFile), (theFormat), (thePage))
#else
#define CallGXSpoolPageProc(userRoutine, theSpoolFile, theFormat, thePage)        \
        (*(userRoutine))((theSpoolFile), (theFormat), (thePage))
#endif
#define Send_GXSpoolPage(theSpoolFile, theFormat, thePage) \
          SendMessage(0x00000010, theSpoolFile, theFormat, thePage)

#define Forward_GXSpoolPage(theSpoolFile, theFormat, thePage) \
          ForwardThisMessage((void *) theSpoolFile, (void *) theFormat, (void *) thePage)
typedef OSErr (*GXSpoolDataProcPtr)(gxSpoolFile theSpoolFile, Ptr data, long *length);

#if GENERATINGCFM
typedef UniversalProcPtr GXSpoolDataUPP;
#else
typedef GXSpoolDataProcPtr GXSpoolDataUPP;
#endif

enum {
    uppGXSpoolDataProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long *)))
};

#if GENERATINGCFM
#define NewGXSpoolDataProc(userRoutine)        \
        (GXSpoolDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSpoolDataProcInfo, GetCurrentArchitecture())
#else
#define NewGXSpoolDataProc(userRoutine)        \
        ((GXSpoolDataUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXSpoolDataProc(userRoutine, theSpoolFile, data, length)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSpoolDataProcInfo, (theSpoolFile), (data), (length))
#else
#define CallGXSpoolDataProc(userRoutine, theSpoolFile, data, length)        \
        (*(userRoutine))((theSpoolFile), (data), (length))
#endif
#define Send_GXSpoolData(theSpoolFile, data, length) \
          SendMessage(0x00000011, theSpoolFile, data, length)

#define Forward_GXSpoolData(theSpoolFile, data, length) \
          ForwardThisMessage((void *) theSpoolFile, (void *) data, (void *) length)
typedef OSErr (*GXSpoolResourceProcPtr)(gxSpoolFile theSpoolFile, Handle theResource, ResType theType, long id);

#if GENERATINGCFM
typedef UniversalProcPtr GXSpoolResourceUPP;
#else
typedef GXSpoolResourceProcPtr GXSpoolResourceUPP;
#endif

enum {
    uppGXSpoolResourceProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ResType)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long)))
};

#if GENERATINGCFM
#define NewGXSpoolResourceProc(userRoutine)        \
        (GXSpoolResourceUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSpoolResourceProcInfo, GetCurrentArchitecture())
#else
#define NewGXSpoolResourceProc(userRoutine)        \
        ((GXSpoolResourceUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXSpoolResourceProc(userRoutine, theSpoolFile, theResource, theType, id)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSpoolResourceProcInfo, (theSpoolFile), (theResource), (theType), (id))
#else
#define CallGXSpoolResourceProc(userRoutine, theSpoolFile, theResource, theType, id)        \
        (*(userRoutine))((theSpoolFile), (theResource), (theType), (id))
#endif
#define Send_GXSpoolResource(theSpoolFile, theResource, theType, id) \
          SendMessage(0x00000012, theSpoolFile, theResource, \
                            theType, id)

#define Forward_GXSpoolResource(theSpoolFile, theResource, theType, id) \
          ForwardThisMessage((void *) theSpoolFile, (void *) theResource, \
                                      (void *) theType, (void *) (id))
typedef OSErr (*GXCompleteSpoolFileProcPtr)(gxSpoolFile theSpoolFile);

#if GENERATINGCFM
typedef UniversalProcPtr GXCompleteSpoolFileUPP;
#else
typedef GXCompleteSpoolFileProcPtr GXCompleteSpoolFileUPP;
#endif

enum {
    uppGXCompleteSpoolFileProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
};

#if GENERATINGCFM
#define NewGXCompleteSpoolFileProc(userRoutine)        \
        (GXCompleteSpoolFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCompleteSpoolFileProcInfo, GetCurrentArchitecture())
#else
#define NewGXCompleteSpoolFileProc(userRoutine)        \
        ((GXCompleteSpoolFileUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCompleteSpoolFileProc(userRoutine, theSpoolFile)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCompleteSpoolFileProcInfo, (theSpoolFile))
#else
#define CallGXCompleteSpoolFileProc(userRoutine, theSpoolFile)        \
        (*(userRoutine))((theSpoolFile))
#endif
#define Send_GXCompleteSpoolFile(theSpoolFile) \
          SendMessage(0x00000013, theSpoolFile)

#define Forward_GXCompleteSpoolFile(theSpoolFile) \
          ForwardThisMessage((void *) (theSpoolFile))
typedef OSErr (*GXCountPagesProcPtr)(gxSpoolFile theSpoolFile, long *numPages);

#if GENERATINGCFM
typedef UniversalProcPtr GXCountPagesUPP;
#else
typedef GXCountPagesProcPtr GXCountPagesUPP;
#endif

enum {
    uppGXCountPagesProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long *)))
};

#if GENERATINGCFM
#define NewGXCountPagesProc(userRoutine)        \
        (GXCountPagesUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCountPagesProcInfo, GetCurrentArchitecture())
#else
#define NewGXCountPagesProc(userRoutine)        \
        ((GXCountPagesUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCountPagesProc(userRoutine, theSpoolFile, numPages)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCountPagesProcInfo, (theSpoolFile), (numPages))
#else
#define CallGXCountPagesProc(userRoutine, theSpoolFile, numPages)        \
        (*(userRoutine))((theSpoolFile), (numPages))
#endif
#define Send_GXCountPages(theSpoolFile, numPages) \
          SendMessage(0x00000014, theSpoolFile, numPages)

#define Forward_GXCountPages(theSpoolFile, numPages) \
          ForwardThisMessage((void *) (theSpoolFile), (void *) (numPages))
typedef OSErr (*GXDespoolPageProcPtr)(gxSpoolFile theSpoolFile, long numPages, gxFormat theFormat, gxShape *thePage, Boolean *formatChanged);

#if GENERATINGCFM
typedef UniversalProcPtr GXDespoolPageUPP;
#else
typedef GXDespoolPageProcPtr GXDespoolPageUPP;
#endif

enum {
    uppGXDespoolPageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(gxShape *)))
         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Boolean *)))
};

#if GENERATINGCFM
#define NewGXDespoolPageProc(userRoutine)        \
        (GXDespoolPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDespoolPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXDespoolPageProc(userRoutine)        \
        ((GXDespoolPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDespoolPageProc(userRoutine, theSpoolFile, numPages, theFormat, thePage, formatChanged)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDespoolPageProcInfo, (theSpoolFile), (numPages), (theFormat), (thePage), (formatChanged))
#else
#define CallGXDespoolPageProc(userRoutine, theSpoolFile, numPages, theFormat, thePage, formatChanged)        \
        (*(userRoutine))((theSpoolFile), (numPages), (theFormat), (thePage), (formatChanged))
#endif
#define Send_GXDespoolPage(theSpoolFile, numPages, theFormat, thePage, formatChanged) \
          SendMessage(0x00000015, theSpoolFile, numPages, \
                            theFormat, thePage, formatChanged)

#define Forward_GXDespoolPage(theSpoolFile, numPages, theFormat, thePage, formatChanged) \
          ForwardThisMessage((void *) (theSpoolFile), (void *) (numPages), (void *) (theFormat), \
                                      (void *) (thePage), (void *) (formatChanged))
typedef OSErr (*GXDespoolDataProcPtr)(gxSpoolFile theSpoolFile, Ptr data, long *length);

#if GENERATINGCFM
typedef UniversalProcPtr GXDespoolDataUPP;
#else
typedef GXDespoolDataProcPtr GXDespoolDataUPP;
#endif

enum {
    uppGXDespoolDataProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long *)))
};

#if GENERATINGCFM
#define NewGXDespoolDataProc(userRoutine)        \
        (GXDespoolDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDespoolDataProcInfo, GetCurrentArchitecture())
#else
#define NewGXDespoolDataProc(userRoutine)        \
        ((GXDespoolDataUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDespoolDataProc(userRoutine, theSpoolFile, data, length)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDespoolDataProcInfo, (theSpoolFile), (data), (length))
#else
#define CallGXDespoolDataProc(userRoutine, theSpoolFile, data, length)        \
        (*(userRoutine))((theSpoolFile), (data), (length))
#endif
#define Send_GXDespoolData(theSpoolFile, data, length) \
          SendMessage(0x00000016, theSpoolFile, data, length)

#define Forward_GXDespoolData(theSpoolFile, data, length) \
          ForwardThisMessage((void *) (theSpoolFile), (void *) (data), (void *) (length))
typedef OSErr (*GXDespoolResourceProcPtr)(gxSpoolFile theSpoolFile, ResType theType, long id, Handle *theResource);

#if GENERATINGCFM
typedef UniversalProcPtr GXDespoolResourceUPP;
#else
typedef GXDespoolResourceProcPtr GXDespoolResourceUPP;
#endif

enum {
    uppGXDespoolResourceProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(ResType)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Handle *)))
};

#if GENERATINGCFM
#define NewGXDespoolResourceProc(userRoutine)        \
        (GXDespoolResourceUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDespoolResourceProcInfo, GetCurrentArchitecture())
#else
#define NewGXDespoolResourceProc(userRoutine)        \
        ((GXDespoolResourceUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDespoolResourceProc(userRoutine, theSpoolFile, theType, id, theResource)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDespoolResourceProcInfo, (theSpoolFile), (theType), (id), (theResource))
#else
#define CallGXDespoolResourceProc(userRoutine, theSpoolFile, theType, id, theResource)        \
        (*(userRoutine))((theSpoolFile), (theType), (id), (theResource))
#endif
#define Send_GXDespoolResource(theSpoolFile, theType, id, theResource) \
          SendMessage(0x00000017, theSpoolFile, theType, \
                            id, theResource)

#define Forward_GXDespoolResource(theSpoolFile, theType, id, theResource) \
          ForwardThisMessage((void *) (theSpoolFile), (void *) (theType), (void *) (id), \
                                      (void *) (theResource))
typedef OSErr (*GXCloseSpoolFileProcPtr)(gxSpoolFile theSpoolFile, long closeOptions);

#if GENERATINGCFM
typedef UniversalProcPtr GXCloseSpoolFileUPP;
#else
typedef GXCloseSpoolFileProcPtr GXCloseSpoolFileUPP;
#endif

enum {
    uppGXCloseSpoolFileProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
};

#if GENERATINGCFM
#define NewGXCloseSpoolFileProc(userRoutine)        \
        (GXCloseSpoolFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCloseSpoolFileProcInfo, GetCurrentArchitecture())
#else
#define NewGXCloseSpoolFileProc(userRoutine)        \
        ((GXCloseSpoolFileUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCloseSpoolFileProc(userRoutine, theSpoolFile, closeOptions)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCloseSpoolFileProcInfo, (theSpoolFile), (closeOptions))
#else
#define CallGXCloseSpoolFileProc(userRoutine, theSpoolFile, closeOptions)        \
        (*(userRoutine))((theSpoolFile), (closeOptions))
#endif
#define Send_GXCloseSpoolFile(theSpoolFile, closeOptions) \
          SendMessage(0x00000018, theSpoolFile, closeOptions)

#define Forward_GXCloseSpoolFile(theSpoolFile, closeOptions) \
          ForwardThisMessage((void *) (theSpoolFile), (void *) (closeOptions))
typedef OSErr (*GXStartJobProcPtr)(StringPtr docName, long pageCount);

#if GENERATINGCFM
typedef UniversalProcPtr GXStartJobUPP;
#else
typedef GXStartJobProcPtr GXStartJobUPP;
#endif

enum {
    uppGXStartJobProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(StringPtr)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
};

#if GENERATINGCFM
#define NewGXStartJobProc(userRoutine)        \
        (GXStartJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXStartJobProcInfo, GetCurrentArchitecture())
#else
#define NewGXStartJobProc(userRoutine)        \
        ((GXStartJobUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXStartJobProc(userRoutine, docName, pageCount)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXStartJobProcInfo, (docName), (pageCount))
#else
#define CallGXStartJobProc(userRoutine, docName, pageCount)        \
        (*(userRoutine))((docName), (pageCount))
#endif
#define Send_GXStartJob(docName, pageCount) \
          SendMessage(0x00000019, docName, pageCount)

#define Forward_GXStartJob(docName, pageCount) \
          ForwardThisMessage((void *) (docName), (void *) (pageCount))
typedef OSErr (*GXFinishJobProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXFinishJobUPP;
#else
typedef GXFinishJobProcPtr GXFinishJobUPP;
#endif

enum {
    uppGXFinishJobProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
};

#if GENERATINGCFM
#define NewGXFinishJobProc(userRoutine)        \
        (GXFinishJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFinishJobProcInfo, GetCurrentArchitecture())
#else
#define NewGXFinishJobProc(userRoutine)        \
        ((GXFinishJobUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFinishJobProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFinishJobProcInfo)
#else
#define CallGXFinishJobProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXFinishJob() SendMessage(0x0000001A)
#define Forward_GXFinishJob() ForwardThisMessage((void *) (0))
typedef OSErr (*GXStartPageProcPtr)(gxFormat theFormat, long numViewPorts, gxViewPort *viewPortList);

#if GENERATINGCFM
typedef UniversalProcPtr GXStartPageUPP;
#else
typedef GXStartPageProcPtr GXStartPageUPP;
#endif

enum {
    uppGXStartPageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxViewPort *)))
};

#if GENERATINGCFM
#define NewGXStartPageProc(userRoutine)        \
        (GXStartPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXStartPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXStartPageProc(userRoutine)        \
        ((GXStartPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXStartPageProc(userRoutine, theFormat, numViewPorts, viewPortList)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXStartPageProcInfo, (theFormat), (numViewPorts), (viewPortList))
#else
#define CallGXStartPageProc(userRoutine, theFormat, numViewPorts, viewPortList)        \
        (*(userRoutine))((theFormat), (numViewPorts), (viewPortList))
#endif
#define Send_GXStartPage(theFormat, numViewPorts, viewPortList) \
          SendMessage(0x0000001B, theFormat, numViewPorts, viewPortList)

#define Forward_GXStartPage(theFormat, numViewPorts, viewPortList) \
          ForwardThisMessage((void *) (theFormat), (void *) (numViewPorts), (void *) (viewPortList))
typedef OSErr (*GXFinishPageProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXFinishPageUPP;
#else
typedef GXFinishPageProcPtr GXFinishPageUPP;
#endif

enum {
    uppGXFinishPageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
};

#if GENERATINGCFM
#define NewGXFinishPageProc(userRoutine)        \
        (GXFinishPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFinishPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXFinishPageProc(userRoutine)        \
        ((GXFinishPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFinishPageProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFinishPageProcInfo)
#else
#define CallGXFinishPageProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXFinishPage() SendMessage(0x0000001C)
#define Forward_GXFinishPage() ForwardThisMessage((void *) (0))
typedef OSErr (*GXPrintPageProcPtr)(gxFormat theFormat, gxShape thePage);

#if GENERATINGCFM
typedef UniversalProcPtr GXPrintPageUPP;
#else
typedef GXPrintPageProcPtr GXPrintPageUPP;
#endif

enum {
    uppGXPrintPageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxShape)))
};

#if GENERATINGCFM
#define NewGXPrintPageProc(userRoutine)        \
        (GXPrintPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXPrintPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXPrintPageProc(userRoutine)        \
        ((GXPrintPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXPrintPageProc(userRoutine, theFormat, thePage)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXPrintPageProcInfo, (theFormat), (thePage))
#else
#define CallGXPrintPageProc(userRoutine, theFormat, thePage)        \
        (*(userRoutine))((theFormat), (thePage))
#endif
#define Send_GXPrintPage(theFormat, thePage) \
          SendMessage(0x0000001D, theFormat, thePage)

#define Forward_GXPrintPage(theFormat, thePage) \
          ForwardThisMessage((void *) (theFormat), (void *) (thePage))
typedef OSErr (*GXSetupImageDataProcPtr)(void *imageData);

#if GENERATINGCFM
typedef UniversalProcPtr GXSetupImageDataUPP;
#else
typedef GXSetupImageDataProcPtr GXSetupImageDataUPP;
#endif

enum {
    uppGXSetupImageDataProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXSetupImageDataProc(userRoutine)        \
        (GXSetupImageDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSetupImageDataProcInfo, GetCurrentArchitecture())
#else
#define NewGXSetupImageDataProc(userRoutine)        \
        ((GXSetupImageDataUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXSetupImageDataProc(userRoutine, imageData)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSetupImageDataProcInfo, (imageData))
#else
#define CallGXSetupImageDataProc(userRoutine, imageData)        \
        (*(userRoutine))((imageData))
#endif
#define Send_GXSetupImageData(imageData) \
          SendMessage(0x0000001E, imageData)

#define Forward_GXSetupImageData(imageData) \
          ForwardThisMessage((void *) (imageData))
typedef OSErr (*GXImageJobProcPtr)(gxSpoolFile theSpoolFile, long *closeOptions);

#if GENERATINGCFM
typedef UniversalProcPtr GXImageJobUPP;
#else
typedef GXImageJobProcPtr GXImageJobUPP;
#endif

enum {
    uppGXImageJobProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long *)))
};

#if GENERATINGCFM
#define NewGXImageJobProc(userRoutine)        \
        (GXImageJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXImageJobProcInfo, GetCurrentArchitecture())
#else
#define NewGXImageJobProc(userRoutine)        \
        ((GXImageJobUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXImageJobProc(userRoutine, theSpoolFile, closeOptions)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXImageJobProcInfo, (theSpoolFile), (closeOptions))
#else
#define CallGXImageJobProc(userRoutine, theSpoolFile, closeOptions)        \
        (*(userRoutine))((theSpoolFile), (closeOptions))
#endif
#define Send_GXImageJob(theSpoolFile, closeOptions) \
          SendMessage(0x0000001F, theSpoolFile, closeOptions)

#define Forward_GXImageJob(theSpoolFile, closeOptions) \
          ForwardThisMessage((void *) (theSpoolFile), (void *) (closeOptions))
typedef OSErr (*GXImageDocumentProcPtr)(gxSpoolFile theSpoolFile, void *imageData);

#if GENERATINGCFM
typedef UniversalProcPtr GXImageDocumentUPP;
#else
typedef GXImageDocumentProcPtr GXImageDocumentUPP;
#endif

enum {
    uppGXImageDocumentProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXImageDocumentProc(userRoutine)        \
        (GXImageDocumentUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXImageDocumentProcInfo, GetCurrentArchitecture())
#else
#define NewGXImageDocumentProc(userRoutine)        \
        ((GXImageDocumentUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXImageDocumentProc(userRoutine, theSpoolFile, imageData)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXImageDocumentProcInfo, (theSpoolFile), (imageData))
#else
#define CallGXImageDocumentProc(userRoutine, theSpoolFile, imageData)        \
        (*(userRoutine))((theSpoolFile), (imageData))
#endif
#define Send_GXImageDocument(theSpoolFile, imageData) \
          SendMessage(0x00000020, theSpoolFile, imageData)

#define Forward_GXImageDocument(theSpoolFile, imageData) \
          ForwardThisMessage((void *) (theSpoolFile), (void *) (imageData))
typedef OSErr (*GXImagePageProcPtr)(gxSpoolFile theSpoolFile, long pageNumber, gxFormat theFormat, void *imageData);

#if GENERATINGCFM
typedef UniversalProcPtr GXImagePageUPP;
#else
typedef GXImagePageProcPtr GXImagePageUPP;
#endif

enum {
    uppGXImagePageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXImagePageProc(userRoutine)        \
        (GXImagePageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXImagePageProcInfo, GetCurrentArchitecture())
#else
#define NewGXImagePageProc(userRoutine)        \
        ((GXImagePageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXImagePageProc(userRoutine, theSpoolFile, pageNumber, theFormat, imageData)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXImagePageProcInfo, (theSpoolFile), (pageNumber), (theFormat), (imageData))
#else
#define CallGXImagePageProc(userRoutine, theSpoolFile, pageNumber, theFormat, imageData)        \
        (*(userRoutine))((theSpoolFile), (pageNumber), (theFormat), (imageData))
#endif
#define Send_GXImagePage(theSpoolFile, pageNumber, theFormat, imageData) \
          SendMessage(0x00000021, theSpoolFile, pageNumber, theFormat, imageData)

#define Forward_GXImagePage(theSpoolFile, pageNumber, theFormat, imageData) \
          ForwardThisMessage((void *) (theSpoolFile), (void *) (pageNumber), (void *) (theFormat), \
                                      (void *) (imageData))
typedef OSErr (*GXRenderPageProcPtr)(gxFormat theFormat, gxShape thePage, gxPageInfoRecord *pageInfo, void *imageData);

#if GENERATINGCFM
typedef UniversalProcPtr GXRenderPageUPP;
#else
typedef GXRenderPageProcPtr GXRenderPageUPP;
#endif

enum {
    uppGXRenderPageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxShape)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxPageInfoRecord *)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXRenderPageProc(userRoutine)        \
        (GXRenderPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXRenderPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXRenderPageProc(userRoutine)        \
        ((GXRenderPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXRenderPageProc(userRoutine, theFormat, thePage, pageInfo, imageData)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXRenderPageProcInfo, (theFormat), (thePage), (pageInfo), (imageData))
#else
#define CallGXRenderPageProc(userRoutine, theFormat, thePage, pageInfo, imageData)        \
        (*(userRoutine))((theFormat), (thePage), (pageInfo), (imageData))
#endif
#define Send_GXRenderPage(theFormat, thePage, pageInfo, imageData) \
          SendMessage(0x00000022, theFormat, thePage, pageInfo, imageData)

#define Forward_GXRenderPage(theFormat, thePage, pageInfo, imageData) \
          ForwardThisMessage((void *) (theFormat), (void *) (thePage), (void *) (pageInfo), (void *) (imageData))
typedef OSErr (*GXCreateImageFileProcPtr)(FSSpecPtr pFileSpec, long imageFileOptions, long *theImageFile);

#if GENERATINGCFM
typedef UniversalProcPtr GXCreateImageFileUPP;
#else
typedef GXCreateImageFileProcPtr GXCreateImageFileUPP;
#endif

enum {
    uppGXCreateImageFileProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(FSSpecPtr)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long *)))
};

#if GENERATINGCFM
#define NewGXCreateImageFileProc(userRoutine)        \
        (GXCreateImageFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCreateImageFileProcInfo, GetCurrentArchitecture())
#else
#define NewGXCreateImageFileProc(userRoutine)        \
        ((GXCreateImageFileUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCreateImageFileProc(userRoutine, pFileSpec, imageFileOptions, theImageFile)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCreateImageFileProcInfo, (pFileSpec), (imageFileOptions), (theImageFile))
#else
#define CallGXCreateImageFileProc(userRoutine, pFileSpec, imageFileOptions, theImageFile)        \
        (*(userRoutine))((pFileSpec), (imageFileOptions), (theImageFile))
#endif
#define Send_GXCreateImageFile(pFileSpec, imageFileOptions, theImageFile) \
          SendMessage(0x00000023, pFileSpec, imageFileOptions, theImageFile)

#define Forward_GXCreateImageFile(pFileSpec, imageFileOptions, theImageFile) \
          ForwardThisMessage((void *) (pFileSpec), (void *) (imageFileOptions), (void *) (theImageFile))
typedef OSErr (*GXOpenConnectionProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXOpenConnectionUPP;
#else
typedef GXOpenConnectionProcPtr GXOpenConnectionUPP;
#endif

enum {
    uppGXOpenConnectionProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
};

#if GENERATINGCFM
#define NewGXOpenConnectionProc(userRoutine)        \
        (GXOpenConnectionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXOpenConnectionProcInfo, GetCurrentArchitecture())
#else
#define NewGXOpenConnectionProc(userRoutine)        \
        ((GXOpenConnectionUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXOpenConnectionProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXOpenConnectionProcInfo)
#else
#define CallGXOpenConnectionProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXOpenConnection() SendMessage(0x00000024)
#define Forward_GXOpenConnection() ForwardThisMessage((void *) (0))
typedef OSErr (*GXCloseConnectionProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXCloseConnectionUPP;
#else
typedef GXCloseConnectionProcPtr GXCloseConnectionUPP;
#endif

enum {
    uppGXCloseConnectionProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
};

#if GENERATINGCFM
#define NewGXCloseConnectionProc(userRoutine)        \
        (GXCloseConnectionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCloseConnectionProcInfo, GetCurrentArchitecture())
#else
#define NewGXCloseConnectionProc(userRoutine)        \
        ((GXCloseConnectionUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCloseConnectionProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCloseConnectionProcInfo)
#else
#define CallGXCloseConnectionProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXCloseConnection() SendMessage(0x00000025)
#define Forward_GXCloseConnection() ForwardThisMessage((void *) (0))
typedef OSErr (*GXStartSendPageProcPtr)(gxFormat theFormat);

#if GENERATINGCFM
typedef UniversalProcPtr GXStartSendPageUPP;
#else
typedef GXStartSendPageProcPtr GXStartSendPageUPP;
#endif

enum {
    uppGXStartSendPageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
};

#if GENERATINGCFM
#define NewGXStartSendPageProc(userRoutine)        \
        (GXStartSendPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXStartSendPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXStartSendPageProc(userRoutine)        \
        ((GXStartSendPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXStartSendPageProc(userRoutine, theFormat)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXStartSendPageProcInfo, (theFormat))
#else
#define CallGXStartSendPageProc(userRoutine, theFormat)        \
        (*(userRoutine))((theFormat))
#endif
#define Send_GXStartSendPage(theFormat) SendMessage(0x00000026, theFormat)
#define Forward_GXStartSendPage(theFormat) ForwardThisMessage((void *) (theFormat))
typedef OSErr (*GXFinishSendPageProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXFinishSendPageUPP;
#else
typedef GXFinishSendPageProcPtr GXFinishSendPageUPP;
#endif

enum {
    uppGXFinishSendPageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
};

#if GENERATINGCFM
#define NewGXFinishSendPageProc(userRoutine)        \
        (GXFinishSendPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFinishSendPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXFinishSendPageProc(userRoutine)        \
        ((GXFinishSendPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFinishSendPageProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFinishSendPageProcInfo)
#else
#define CallGXFinishSendPageProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXFinishSendPage() SendMessage(0x00000027)
#define Forward_GXFinishSendPage() ForwardThisMessage((void *) (0))
typedef OSErr (*GXWriteDataProcPtr)(Ptr data, long length);

#if GENERATINGCFM
typedef UniversalProcPtr GXWriteDataUPP;
#else
typedef GXWriteDataProcPtr GXWriteDataUPP;
#endif

enum {
    uppGXWriteDataProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
};

#if GENERATINGCFM
#define NewGXWriteDataProc(userRoutine)        \
        (GXWriteDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXWriteDataProcInfo, GetCurrentArchitecture())
#else
#define NewGXWriteDataProc(userRoutine)        \
        ((GXWriteDataUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXWriteDataProc(userRoutine, data, length)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXWriteDataProcInfo, (data), (length))
#else
#define CallGXWriteDataProc(userRoutine, data, length)        \
        (*(userRoutine))((data), (length))
#endif
#define Send_GXWriteData(data, length) SendMessage(0x00000028, data, length)
#define Forward_GXWriteData(data, length) ForwardThisMessage((void *) (data), (void *) (length))
typedef OSErr (*GXBufferDataProcPtr)(Ptr data, long length, long bufferOptions);

#if GENERATINGCFM
typedef UniversalProcPtr GXBufferDataUPP;
#else
typedef GXBufferDataProcPtr GXBufferDataUPP;
#endif

enum {
    uppGXBufferDataProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
};

#if GENERATINGCFM
#define NewGXBufferDataProc(userRoutine)        \
        (GXBufferDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXBufferDataProcInfo, GetCurrentArchitecture())
#else
#define NewGXBufferDataProc(userRoutine)        \
        ((GXBufferDataUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXBufferDataProc(userRoutine, data, length, bufferOptions)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXBufferDataProcInfo, (data), (length), (bufferOptions))
#else
#define CallGXBufferDataProc(userRoutine, data, length, bufferOptions)        \
        (*(userRoutine))((data), (length), (bufferOptions))
#endif
#define Send_GXBufferData(data, length, bufferOptions) \
          SendMessage(0x00000029, data, length, bufferOptions)

#define Forward_GXBufferData(data, length, bufferOptions) \
          ForwardThisMessage((void *) (data), (void *) (length), (void *) (bufferOptions))
typedef OSErr (*GXDumpBufferProcPtr)(gxPrintingBuffer *theBuffer);

#if GENERATINGCFM
typedef UniversalProcPtr GXDumpBufferUPP;
#else
typedef GXDumpBufferProcPtr GXDumpBufferUPP;
#endif

enum {
    uppGXDumpBufferProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrintingBuffer *)))
};

#if GENERATINGCFM
#define NewGXDumpBufferProc(userRoutine)        \
        (GXDumpBufferUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDumpBufferProcInfo, GetCurrentArchitecture())
#else
#define NewGXDumpBufferProc(userRoutine)        \
        ((GXDumpBufferUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDumpBufferProc(userRoutine, theBuffer)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDumpBufferProcInfo, (theBuffer))
#else
#define CallGXDumpBufferProc(userRoutine, theBuffer)        \
        (*(userRoutine))((theBuffer))
#endif
#define Send_GXDumpBuffer(theBuffer) SendMessage(0x0000002A, theBuffer)
#define Forward_GXDumpBuffer(theBuffer) ForwardThisMessage((void *) (theBuffer))
typedef OSErr (*GXFreeBufferProcPtr)(gxPrintingBuffer *theBuffer);

#if GENERATINGCFM
typedef UniversalProcPtr GXFreeBufferUPP;
#else
typedef GXFreeBufferProcPtr GXFreeBufferUPP;
#endif

enum {
    uppGXFreeBufferProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrintingBuffer *)))
};

#if GENERATINGCFM
#define NewGXFreeBufferProc(userRoutine)        \
        (GXFreeBufferUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFreeBufferProcInfo, GetCurrentArchitecture())
#else
#define NewGXFreeBufferProc(userRoutine)        \
        ((GXFreeBufferUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFreeBufferProc(userRoutine, theBuffer)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFreeBufferProcInfo, (theBuffer))
#else
#define CallGXFreeBufferProc(userRoutine, theBuffer)        \
        (*(userRoutine))((theBuffer))
#endif
#define Send_GXFreeBuffer(theBuffer) SendMessage(0x0000002B, theBuffer)
#define Forward_GXFreeBuffer(theBuffer) ForwardThisMessage((void *) (theBuffer))
typedef OSErr (*GXCheckStatusProcPtr)(Ptr data, long length, long statusType, gxOwnerSignature owner);

#if GENERATINGCFM
typedef UniversalProcPtr GXCheckStatusUPP;
#else
typedef GXCheckStatusProcPtr GXCheckStatusUPP;
#endif

enum {
    uppGXCheckStatusProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(gxOwnerSignature)))
};

#if GENERATINGCFM
#define NewGXCheckStatusProc(userRoutine)        \
        (GXCheckStatusUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCheckStatusProcInfo, GetCurrentArchitecture())
#else
#define NewGXCheckStatusProc(userRoutine)        \
        ((GXCheckStatusUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCheckStatusProc(userRoutine, data, length, statusType, owner)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCheckStatusProcInfo, (data), (length), (statusType), (owner))
#else
#define CallGXCheckStatusProc(userRoutine, data, length, statusType, owner)        \
        (*(userRoutine))((data), (length), (statusType), (owner))
#endif
#define Send_GXCheckStatus(data, length, statusType, owner) \
          SendMessage(0x0000002C, data, length, statusType, owner)

#define Forward_GXCheckStatus(data, length, statusType, owner) \
          ForwardThisMessage((void *) (data), (void *) (length), (void *) (statusType), (void *) (owner))
typedef OSErr (*GXGetDeviceStatusProcPtr)(Ptr cmdData, long cmdSize, Ptr responseData, long *responseSize, Str255 termination);

#if GENERATINGCFM
typedef UniversalProcPtr GXGetDeviceStatusUPP;
#else
typedef GXGetDeviceStatusProcPtr GXGetDeviceStatusUPP;
#endif

enum {
    uppGXGetDeviceStatusProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Ptr)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long *)))
         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Str255*)))
};

#if GENERATINGCFM
#define NewGXGetDeviceStatusProc(userRoutine)        \
        (GXGetDeviceStatusUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXGetDeviceStatusProcInfo, GetCurrentArchitecture())
#else
#define NewGXGetDeviceStatusProc(userRoutine)        \
        ((GXGetDeviceStatusUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXGetDeviceStatusProc(userRoutine, cmdData, cmdSize, responseData, responseSize, termination)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXGetDeviceStatusProcInfo, (cmdData), (cmdSize), (responseData), (responseSize), (termination))
#else
#define CallGXGetDeviceStatusProc(userRoutine, cmdData, cmdSize, responseData, responseSize, termination)        \
        (*(userRoutine))((cmdData), (cmdSize), (responseData), (responseSize), (termination))
#endif
#define Send_GXGetDeviceStatus(cmdData, cmdSize, responseData, responseSize, termination) \
          SendMessage(0x0000002D, cmdData, cmdSize, responseData, responseSize, termination)

#define Forward_GXGetDeviceStatus(cmdData, cmdSize, responseData, responseSize, termination) \
          ForwardThisMessage((void *) (cmdData), (void *) (cmdSize), (void *) (responseData), \
                                      (void *) (responseSize), (void *) (termination))
typedef OSErr (*GXFetchTaggedDataProcPtr)(ResType theType, long id, Handle *dataHdl, gxOwnerSignature owner);

#if GENERATINGCFM
typedef UniversalProcPtr GXFetchTaggedDataUPP;
#else
typedef GXFetchTaggedDataProcPtr GXFetchTaggedDataUPP;
#endif

enum {
    uppGXFetchTaggedDataProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ResType)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Handle *)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(gxOwnerSignature)))
};

#if GENERATINGCFM
#define NewGXFetchTaggedDataProc(userRoutine)        \
        (GXFetchTaggedDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFetchTaggedDataProcInfo, GetCurrentArchitecture())
#else
#define NewGXFetchTaggedDataProc(userRoutine)        \
        ((GXFetchTaggedDataUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFetchTaggedDataProc(userRoutine, theType, id, dataHdl, owner)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFetchTaggedDataProcInfo, (theType), (id), (dataHdl), (owner))
#else
#define CallGXFetchTaggedDataProc(userRoutine, theType, id, dataHdl, owner)        \
        (*(userRoutine))((theType), (id), (dataHdl), (owner))
#endif
#define Send_GXFetchTaggedDriverData(tag, id, pHandle) Send_GXFetchTaggedData(tag, id, pHandle, 'drvr')
#define Forward_GXFetchTaggedDriverData(tag, id, pHandle) Forward_GXFetchTaggedData(tag, id, pHandle, 'drvr')
#define Send_GXFetchTaggedData(theType, id, dataHdl, owner) \
          SendMessage(0x0000002E, theType, id, dataHdl, owner)

#define Forward_GXFetchTaggedData(theType, id, dataHdl, owner) \
          ForwardThisMessage((void *) (theType), (void *) (id), (void *) (dataHdl), (void *) (owner))
#endif
#if FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED
typedef OSErr (*GXGetDTPMenuListProcPtr)(MenuHandle menuHdl);

#if GENERATINGCFM
typedef UniversalProcPtr GXGetDTPMenuListUPP;
#else
typedef GXGetDTPMenuListProcPtr GXGetDTPMenuListUPP;
#endif

enum {
    uppGXGetDTPMenuListProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(MenuHandle)))
};

#if GENERATINGCFM
#define NewGXGetDTPMenuListProc(userRoutine)        \
        (GXGetDTPMenuListUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXGetDTPMenuListProcInfo, GetCurrentArchitecture())
#else
#define NewGXGetDTPMenuListProc(userRoutine)        \
        ((GXGetDTPMenuListUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXGetDTPMenuListProc(userRoutine, menuHdl)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXGetDTPMenuListProcInfo, (menuHdl))
#else
#define CallGXGetDTPMenuListProc(userRoutine, menuHdl)        \
        (*(userRoutine))((menuHdl))
#endif
#define    Send_GXGetDTPMenuList(menuHdl) \
            SendMessage(0x0000002F, menuHdl)

#define    Forward_GXGetDTPMenuList(menuHdl) \
            ForwardThisMessage((void *) (menuHdl))
#endif
#if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE
typedef OSErr (*GXDTPMenuSelectProcPtr)(long id);

#if GENERATINGCFM
typedef UniversalProcPtr GXDTPMenuSelectUPP;
#else
typedef GXDTPMenuSelectProcPtr GXDTPMenuSelectUPP;
#endif

enum {
    uppGXDTPMenuSelectProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(long)))
};

#if GENERATINGCFM
#define NewGXDTPMenuSelectProc(userRoutine)        \
        (GXDTPMenuSelectUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDTPMenuSelectProcInfo, GetCurrentArchitecture())
#else
#define NewGXDTPMenuSelectProc(userRoutine)        \
        ((GXDTPMenuSelectUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDTPMenuSelectProc(userRoutine, id)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDTPMenuSelectProcInfo, (id))
#else
#define CallGXDTPMenuSelectProc(userRoutine, id)        \
        (*(userRoutine))((id))
#endif
#define    Send_GXDTPMenuSelect(id) \
            SendMessage(0x00000030, id)

#define    Forward_GXDTPMenuSelect(id) \
            ForwardThisMessage((void *) (id))
typedef OSErr (*GXHandleAlertFilterProcPtr)(gxJob theJob, gxStatusRecord *pStatusRec, DialogPtr pDialog, EventRecord *theEvent, short *itemHit, Boolean *returnImmed);

#if GENERATINGCFM
typedef UniversalProcPtr GXHandleAlertFilterUPP;
#else
typedef GXHandleAlertFilterProcPtr GXHandleAlertFilterUPP;
#endif

enum {
    uppGXHandleAlertFilterProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxJob)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxStatusRecord *)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(DialogPtr)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(EventRecord *)))
         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(short *)))
         | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(Boolean *)))
};

#if GENERATINGCFM
#define NewGXHandleAlertFilterProc(userRoutine)        \
        (GXHandleAlertFilterUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXHandleAlertFilterProcInfo, GetCurrentArchitecture())
#else
#define NewGXHandleAlertFilterProc(userRoutine)        \
        ((GXHandleAlertFilterUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXHandleAlertFilterProc(userRoutine, theJob, pStatusRec, pDialog, theEvent, itemHit, returnImmed)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXHandleAlertFilterProcInfo, (theJob), (pStatusRec), (pDialog), (theEvent), (itemHit), (returnImmed))
#else
#define CallGXHandleAlertFilterProc(userRoutine, theJob, pStatusRec, pDialog, theEvent, itemHit, returnImmed)        \
        (*(userRoutine))((theJob), (pStatusRec), (pDialog), (theEvent), (itemHit), (returnImmed))
#endif
#define    Send_GXHandleAlertFilter(theJob, pStatusRec, pDialog, theEvent, itemHit, returnImmed) \
            SendMessage(0x00000031, theJob, pStatusRec, pDialog, theEvent, itemHit, returnImmed)

#define    Forward_GXHandleAlertFilter(theJob, pStatusRec, pDialog, theEvent, itemHit, returnImmed) \
            ForwardThisMessage((void *) (theJob), (void *) (pStatusRec), (void *) (pDialog), (void *) (theEvent), \
                                     (void *) (itemHit), (void *) (returnImmed))
typedef OSErr (*GXJobFormatModeQueryProcPtr)(gxQueryType theQuery, void *srcData, void *dstData);

#if GENERATINGCFM
typedef UniversalProcPtr GXJobFormatModeQueryUPP;
#else
typedef GXJobFormatModeQueryProcPtr GXJobFormatModeQueryUPP;
#endif

enum {
    uppGXJobFormatModeQueryProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxQueryType)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXJobFormatModeQueryProc(userRoutine)        \
        (GXJobFormatModeQueryUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobFormatModeQueryProcInfo, GetCurrentArchitecture())
#else
#define NewGXJobFormatModeQueryProc(userRoutine)        \
        ((GXJobFormatModeQueryUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXJobFormatModeQueryProc(userRoutine, theQuery, srcData, dstData)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobFormatModeQueryProcInfo, (theQuery), (srcData), (dstData))
#else
#define CallGXJobFormatModeQueryProc(userRoutine, theQuery, srcData, dstData)        \
        (*(userRoutine))((theQuery), (srcData), (dstData))
#endif
#define Send_GXJobFormatModeQuery(theQuery, srcData, dstData) \
          SendMessage(0x00000032, theQuery, srcData, dstData)

#define Forward_GXJobFormatModeQuery(theQuery, srcData, dstData) \
          ForwardThisMessage((void *) (theQuery), (void *) (srcData), (void *) (dstData))
typedef OSErr (*GXWriteStatusToDTPWindowProcPtr)(gxStatusRecord *pStatusRec, gxDisplayRecord *pDisplay);

#if GENERATINGCFM
typedef UniversalProcPtr GXWriteStatusToDTPWindowUPP;
#else
typedef GXWriteStatusToDTPWindowProcPtr GXWriteStatusToDTPWindowUPP;
#endif

enum {
    uppGXWriteStatusToDTPWindowProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord *)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxDisplayRecord *)))
};

#if GENERATINGCFM
#define NewGXWriteStatusToDTPWindowProc(userRoutine)        \
        (GXWriteStatusToDTPWindowUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXWriteStatusToDTPWindowProcInfo, GetCurrentArchitecture())
#else
#define NewGXWriteStatusToDTPWindowProc(userRoutine)        \
        ((GXWriteStatusToDTPWindowUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXWriteStatusToDTPWindowProc(userRoutine, pStatusRec, pDisplay)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXWriteStatusToDTPWindowProcInfo, (pStatusRec), (pDisplay))
#else
#define CallGXWriteStatusToDTPWindowProc(userRoutine, pStatusRec, pDisplay)        \
        (*(userRoutine))((pStatusRec), (pDisplay))
#endif
#define Send_GXWriteStatusToDTPWindow(pStatusRec, pDisplay) \
          SendMessage(0x00000033, pStatusRec, pDisplay)

#define Forward_GXWriteStatusToDTPWindow(pStatusRec, pDisplay) \
          ForwardThisMessage((void *) (pStatusRec), (void *) (pDisplay))
typedef OSErr (*GXInitializeStatusAlertProcPtr)(gxStatusRecord *pStatusRec, DialogPtr *pDialog);

#if GENERATINGCFM
typedef UniversalProcPtr GXInitializeStatusAlertUPP;
#else
typedef GXInitializeStatusAlertProcPtr GXInitializeStatusAlertUPP;
#endif

enum {
    uppGXInitializeStatusAlertProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord *)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(DialogPtr *)))
};

#if GENERATINGCFM
#define NewGXInitializeStatusAlertProc(userRoutine)        \
        (GXInitializeStatusAlertUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXInitializeStatusAlertProcInfo, GetCurrentArchitecture())
#else
#define NewGXInitializeStatusAlertProc(userRoutine)        \
        ((GXInitializeStatusAlertUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXInitializeStatusAlertProc(userRoutine, pStatusRec, pDialog)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXInitializeStatusAlertProcInfo, (pStatusRec), (pDialog))
#else
#define CallGXInitializeStatusAlertProc(userRoutine, pStatusRec, pDialog)        \
        (*(userRoutine))((pStatusRec), (pDialog))
#endif
#define Send_GXInitializeStatusAlert(pStatusRec, pDialog) \
          SendMessage(0x00000034, pStatusRec, pDialog)

#define Forward_GXInitializeStatusAlert(pStatusRec, pDialog) \
          ForwardThisMessage((void *) (pStatusRec), (void *) (pDialog))
typedef OSErr (*GXHandleAlertStatusProcPtr)(gxStatusRecord *pStatusRec);

#if GENERATINGCFM
typedef UniversalProcPtr GXHandleAlertStatusUPP;
#else
typedef GXHandleAlertStatusProcPtr GXHandleAlertStatusUPP;
#endif

enum {
    uppGXHandleAlertStatusProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord *)))
};

#if GENERATINGCFM
#define NewGXHandleAlertStatusProc(userRoutine)        \
        (GXHandleAlertStatusUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXHandleAlertStatusProcInfo, GetCurrentArchitecture())
#else
#define NewGXHandleAlertStatusProc(userRoutine)        \
        ((GXHandleAlertStatusUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXHandleAlertStatusProc(userRoutine, pStatusRec)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXHandleAlertStatusProcInfo, (pStatusRec))
#else
#define CallGXHandleAlertStatusProc(userRoutine, pStatusRec)        \
        (*(userRoutine))((pStatusRec))
#endif
#define Send_GXHandleAlertStatus(pStatusRec) \
          SendMessage(0x00000035, pStatusRec)

#define Forward_GXHandleAlertStatus(pStatusRec) \
          ForwardThisMessage((void *) (pStatusRec))
typedef OSErr (*GXHandleAlertEventProcPtr)(gxStatusRecord *pStatusRec, DialogPtr pDialog, EventRecord *theEvent, short *response);

#if GENERATINGCFM
typedef UniversalProcPtr GXHandleAlertEventUPP;
#else
typedef GXHandleAlertEventProcPtr GXHandleAlertEventUPP;
#endif

enum {
    uppGXHandleAlertEventProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord *)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(DialogPtr)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(EventRecord *)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(short *)))
};

#if GENERATINGCFM
#define NewGXHandleAlertEventProc(userRoutine)        \
        (GXHandleAlertEventUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXHandleAlertEventProcInfo, GetCurrentArchitecture())
#else
#define NewGXHandleAlertEventProc(userRoutine)        \
        ((GXHandleAlertEventUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXHandleAlertEventProc(userRoutine, pStatusRec, pDialog, theEvent, response)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXHandleAlertEventProcInfo, (pStatusRec), (pDialog), (theEvent), (response))
#else
#define CallGXHandleAlertEventProc(userRoutine, pStatusRec, pDialog, theEvent, response)        \
        (*(userRoutine))((pStatusRec), (pDialog), (theEvent), (response))
#endif
#define Send_GXHandleAlertEvent(pStatusRec, pDialog, theEvent, response) \
          SendMessage(0x00000036, pStatusRec, pDialog, theEvent, response)

#define Forward_GXHandleAlertEvent(pStatusRec, pDialog, theEvent, response) \
          ForwardThisMessage((void *) (pStatusRec), (void *) (pDialog), \
                                      (void *) (theEvent), (void *) (response))
typedef void (*GXCleanupStartJobProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXCleanupStartJobUPP;
#else
typedef GXCleanupStartJobProcPtr GXCleanupStartJobUPP;
#endif

enum {
    uppGXCleanupStartJobProcInfo = kCStackBased
};

#if GENERATINGCFM
#define NewGXCleanupStartJobProc(userRoutine)        \
        (GXCleanupStartJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCleanupStartJobProcInfo, GetCurrentArchitecture())
#else
#define NewGXCleanupStartJobProc(userRoutine)        \
        ((GXCleanupStartJobUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCleanupStartJobProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCleanupStartJobProcInfo)
#else
#define CallGXCleanupStartJobProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXCleanupStartJob() ((void) SendMessage(0x00000037))
#define Forward_GXCleanupStartJob() ((void) ForwardThisMessage((void *) (0)))
typedef void (*GXCleanupStartPageProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXCleanupStartPageUPP;
#else
typedef GXCleanupStartPageProcPtr GXCleanupStartPageUPP;
#endif

enum {
    uppGXCleanupStartPageProcInfo = kCStackBased
};

#if GENERATINGCFM
#define NewGXCleanupStartPageProc(userRoutine)        \
        (GXCleanupStartPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCleanupStartPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXCleanupStartPageProc(userRoutine)        \
        ((GXCleanupStartPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCleanupStartPageProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCleanupStartPageProcInfo)
#else
#define CallGXCleanupStartPageProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXCleanupStartPage() ((void) SendMessage(0x00000038))
#define Forward_GXCleanupStartPage() ((void) ForwardThisMessage((void *) (0)))
typedef void (*GXCleanupOpenConnectionProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXCleanupOpenConnectionUPP;
#else
typedef GXCleanupOpenConnectionProcPtr GXCleanupOpenConnectionUPP;
#endif

enum {
    uppGXCleanupOpenConnectionProcInfo = kCStackBased
};

#if GENERATINGCFM
#define NewGXCleanupOpenConnectionProc(userRoutine)        \
        (GXCleanupOpenConnectionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCleanupOpenConnectionProcInfo, GetCurrentArchitecture())
#else
#define NewGXCleanupOpenConnectionProc(userRoutine)        \
        ((GXCleanupOpenConnectionUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCleanupOpenConnectionProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCleanupOpenConnectionProcInfo)
#else
#define CallGXCleanupOpenConnectionProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXCleanupOpenConnection() ((void) SendMessage(0x00000039))
#define Forward_GXCleanupOpenConnection() ((void) ForwardThisMessage((void *) (0)))
typedef void (*GXCleanupStartSendPageProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXCleanupStartSendPageUPP;
#else
typedef GXCleanupStartSendPageProcPtr GXCleanupStartSendPageUPP;
#endif

enum {
    uppGXCleanupStartSendPageProcInfo = kCStackBased
};

#if GENERATINGCFM
#define NewGXCleanupStartSendPageProc(userRoutine)        \
        (GXCleanupStartSendPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCleanupStartSendPageProcInfo, GetCurrentArchitecture())
#else
#define NewGXCleanupStartSendPageProc(userRoutine)        \
        ((GXCleanupStartSendPageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCleanupStartSendPageProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCleanupStartSendPageProcInfo)
#else
#define CallGXCleanupStartSendPageProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXCleanupStartSendPage()  ((void) SendMessage(0x0000003A))
#define Forward_GXCleanupStartSendPage() ((void) ForwardThisMessage((void *) (0)))
typedef OSErr (*GXDefaultDesktopPrinterProcPtr)(Str31 dtpName);

#if GENERATINGCFM
typedef UniversalProcPtr GXDefaultDesktopPrinterUPP;
#else
typedef GXDefaultDesktopPrinterProcPtr GXDefaultDesktopPrinterUPP;
#endif

enum {
    uppGXDefaultDesktopPrinterProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Str31*)))
};

#if GENERATINGCFM
#define NewGXDefaultDesktopPrinterProc(userRoutine)        \
        (GXDefaultDesktopPrinterUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultDesktopPrinterProcInfo, GetCurrentArchitecture())
#else
#define NewGXDefaultDesktopPrinterProc(userRoutine)        \
        ((GXDefaultDesktopPrinterUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDefaultDesktopPrinterProc(userRoutine, dtpName)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultDesktopPrinterProcInfo, (dtpName))
#else
#define CallGXDefaultDesktopPrinterProc(userRoutine, dtpName)        \
        (*(userRoutine))((dtpName))
#endif
#define Send_GXDefaultDesktopPrinter(dtpName) SendMessage(0x0000003B, dtpName)
#define Forward_GXDefaultDesktopPrinter(dtpName) ForwardThisMessage((void *) (dtpName))
typedef OSErr (*GXCaptureOutputDeviceProcPtr)(Boolean capture);

#if GENERATINGCFM
typedef UniversalProcPtr GXCaptureOutputDeviceUPP;
#else
typedef GXCaptureOutputDeviceProcPtr GXCaptureOutputDeviceUPP;
#endif

enum {
    uppGXCaptureOutputDeviceProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Boolean)))
};

#if GENERATINGCFM
#define NewGXCaptureOutputDeviceProc(userRoutine)        \
        (GXCaptureOutputDeviceUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCaptureOutputDeviceProcInfo, GetCurrentArchitecture())
#else
#define NewGXCaptureOutputDeviceProc(userRoutine)        \
        ((GXCaptureOutputDeviceUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXCaptureOutputDeviceProc(userRoutine, capture)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCaptureOutputDeviceProcInfo, (capture))
#else
#define CallGXCaptureOutputDeviceProc(userRoutine, capture)        \
        (*(userRoutine))((capture))
#endif
#define Send_GXCaptureOutputDevice(capture) SendMessage(0x0000003C, capture)
#define Forward_GXCaptureOutputDevice(capture) ForwardThisMessage((void *) (capture))
typedef OSErr (*GXOpenConnectionRetryProcPtr)(ResType theType, void *aVoid, Boolean *retryopenPtr, OSErr anErr);

#if GENERATINGCFM
typedef UniversalProcPtr GXOpenConnectionRetryUPP;
#else
typedef GXOpenConnectionRetryProcPtr GXOpenConnectionRetryUPP;
#endif

enum {
    uppGXOpenConnectionRetryProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ResType)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Boolean *)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(OSErr)))
};

#if GENERATINGCFM
#define NewGXOpenConnectionRetryProc(userRoutine)        \
        (GXOpenConnectionRetryUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXOpenConnectionRetryProcInfo, GetCurrentArchitecture())
#else
#define NewGXOpenConnectionRetryProc(userRoutine)        \
        ((GXOpenConnectionRetryUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXOpenConnectionRetryProc(userRoutine, theType, aVoid, retryopenPtr, anErr)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXOpenConnectionRetryProcInfo, (theType), (aVoid), (retryopenPtr), (anErr))
#else
#define CallGXOpenConnectionRetryProc(userRoutine, theType, aVoid, retryopenPtr, anErr)        \
        (*(userRoutine))((theType), (aVoid), (retryopenPtr), (anErr))
#endif
#define Send_GXOpenConnectionRetry(theType, aVoid, retryopenPtr, anErr) \
          SendMessage(0x0000003D, theType, aVoid, retryopenPtr, anErr)

#define Forward_GXOpenConnectionRetry(theType, aVoid, retryopenPtr, anErr) \
          ForwardThisMessage((void *) (theType), (void *) (aVoid), (void *) (retryopenPtr), (void *) (anErr))
typedef OSErr (*GXExamineSpoolFileProcPtr)(gxSpoolFile theSpoolFile);

#if GENERATINGCFM
typedef UniversalProcPtr GXExamineSpoolFileUPP;
#else
typedef GXExamineSpoolFileProcPtr GXExamineSpoolFileUPP;
#endif

enum {
    uppGXExamineSpoolFileProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
};

#if GENERATINGCFM
#define NewGXExamineSpoolFileProc(userRoutine)        \
        (GXExamineSpoolFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXExamineSpoolFileProcInfo, GetCurrentArchitecture())
#else
#define NewGXExamineSpoolFileProc(userRoutine)        \
        ((GXExamineSpoolFileUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXExamineSpoolFileProc(userRoutine, theSpoolFile)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXExamineSpoolFileProcInfo, (theSpoolFile))
#else
#define CallGXExamineSpoolFileProc(userRoutine, theSpoolFile)        \
        (*(userRoutine))((theSpoolFile))
#endif
#define Send_GXExamineSpoolFile(theSpoolFile) SendMessage(0x0000003E, theSpoolFile)
#define Forward_GXExamineSpoolFile(theSpoolFile) ForwardThisMessage((void *) (theSpoolFile))
typedef OSErr (*GXFinishSendPlaneProcPtr)(void );

#if GENERATINGCFM
typedef UniversalProcPtr GXFinishSendPlaneUPP;
#else
typedef GXFinishSendPlaneProcPtr GXFinishSendPlaneUPP;
#endif

enum {
    uppGXFinishSendPlaneProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
};

#if GENERATINGCFM
#define NewGXFinishSendPlaneProc(userRoutine)        \
        (GXFinishSendPlaneUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFinishSendPlaneProcInfo, GetCurrentArchitecture())
#else
#define NewGXFinishSendPlaneProc(userRoutine)        \
        ((GXFinishSendPlaneUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFinishSendPlaneProc(userRoutine)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFinishSendPlaneProcInfo)
#else
#define CallGXFinishSendPlaneProc(userRoutine)        \
        (*(userRoutine))()
#endif
#define Send_GXFinishSendPlane() SendMessage(0x0000003F)
#define Forward_GXFinishSendPlane() ForwardThisMessage((void *) (0))
typedef OSErr (*GXDoesPaperFitProcPtr)(gxTrayIndex whichTray, gxPaperType paper, Boolean *fits);

#if GENERATINGCFM
typedef UniversalProcPtr GXDoesPaperFitUPP;
#else
typedef GXDoesPaperFitProcPtr GXDoesPaperFitUPP;
#endif

enum {
    uppGXDoesPaperFitProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxTrayIndex)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxPaperType)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Boolean *)))
};

#if GENERATINGCFM
#define NewGXDoesPaperFitProc(userRoutine)        \
        (GXDoesPaperFitUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDoesPaperFitProcInfo, GetCurrentArchitecture())
#else
#define NewGXDoesPaperFitProc(userRoutine)        \
        ((GXDoesPaperFitUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXDoesPaperFitProc(userRoutine, whichTray, paper, fits)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDoesPaperFitProcInfo, (whichTray), (paper), (fits))
#else
#define CallGXDoesPaperFitProc(userRoutine, whichTray, paper, fits)        \
        (*(userRoutine))((whichTray), (paper), (fits))
#endif
#define Send_GXDoesPaperFit(whichTray, paper, fits) \
          SendMessage(0x00000040, whichTray, paper, fits)

#define Forward_GXDoesPaperFit(whichTray, paper, fits) \
          ForwardThisMessage((void *) (whichTray), (void *) (paper), (void *) (fits))
#endif
#if FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED
typedef OSErr (*GXChooserMessageProcPtr)(long message, long caller, StringPtr objName, StringPtr zoneName, ListHandle theList, long p2);

#if GENERATINGCFM
typedef UniversalProcPtr GXChooserMessageUPP;
#else
typedef GXChooserMessageProcPtr GXChooserMessageUPP;
#endif

enum {
    uppGXChooserMessageProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(StringPtr)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(StringPtr)))
         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(ListHandle)))
         | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(long)))
};

#if GENERATINGCFM
#define NewGXChooserMessageProc(userRoutine)        \
        (GXChooserMessageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXChooserMessageProcInfo, GetCurrentArchitecture())
#else
#define NewGXChooserMessageProc(userRoutine)        \
        ((GXChooserMessageUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXChooserMessageProc(userRoutine, message, caller, objName, zoneName, theList, p2)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXChooserMessageProcInfo, (message), (caller), (objName), (zoneName), (theList), (p2))
#else
#define CallGXChooserMessageProc(userRoutine, message, caller, objName, zoneName, theList, p2)        \
        (*(userRoutine))((message), (caller), (objName), (zoneName), (theList), (p2))
#endif
#define Send_GXChooserMessage(message, caller, objName, zoneName, theList, p2) \
          SendMessage(0x00000041, message, caller, objName, zoneName, theList, p2)

#define Forward_GXChooserMessage(message, caller, objName, zoneName, theList, p2) \
          ForwardThisMessage((void *) (message), (void *) (caller), (void *) (objName), \
                                      (void *) (zoneName), (void *) (theList), (void *) (p2))
#endif
#if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE
typedef OSErr (*GXFindPrinterProfileProcPtr)(gxPrinter thePrinter, void *searchData, long index, gxColorProfile *returnedProfile, long *numProfiles);

#if GENERATINGCFM
typedef UniversalProcPtr GXFindPrinterProfileUPP;
#else
typedef GXFindPrinterProfileProcPtr GXFindPrinterProfileUPP;
#endif

enum {
    uppGXFindPrinterProfileProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrinter)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(gxColorProfile *)))
         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long *)))
};

#if GENERATINGCFM
#define NewGXFindPrinterProfileProc(userRoutine)        \
        (GXFindPrinterProfileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFindPrinterProfileProcInfo, GetCurrentArchitecture())
#else
#define NewGXFindPrinterProfileProc(userRoutine)        \
        ((GXFindPrinterProfileUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFindPrinterProfileProc(userRoutine, thePrinter, searchData, index, returnedProfile, numProfiles)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFindPrinterProfileProcInfo, (thePrinter), (searchData), (index), (returnedProfile), (numProfiles))
#else
#define CallGXFindPrinterProfileProc(userRoutine, thePrinter, searchData, index, returnedProfile, numProfiles)        \
        (*(userRoutine))((thePrinter), (searchData), (index), (returnedProfile), (numProfiles))
#endif
#define Send_GXFindPrinterProfile(thePrinter, searchData, index, returnedProfile, numProfiles) \
          SendMessage(0x00000042, thePrinter, searchData, index, returnedProfile, numProfiles)

#define Forward_GXFindPrinterProfile(thePrinter, searchData, index, returnedProfile, numProfiles) \
          ForwardThisMessage((void *) (thePrinter), (void *) (searchData), (void *) (index), (void *) (returnedProfile), (void *) (numProfiles))
typedef OSErr (*GXFindFormatProfileProcPtr)(gxFormat theFormat, void *searchData, long index, gxColorProfile *returnedProfile, long *numProfiles);

#if GENERATINGCFM
typedef UniversalProcPtr GXFindFormatProfileUPP;
#else
typedef GXFindFormatProfileProcPtr GXFindFormatProfileUPP;
#endif

enum {
    uppGXFindFormatProfileProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(gxColorProfile *)))
         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long *)))
};

#if GENERATINGCFM
#define NewGXFindFormatProfileProc(userRoutine)        \
        (GXFindFormatProfileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFindFormatProfileProcInfo, GetCurrentArchitecture())
#else
#define NewGXFindFormatProfileProc(userRoutine)        \
        ((GXFindFormatProfileUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXFindFormatProfileProc(userRoutine, theFormat, searchData, index, returnedProfile, numProfiles)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFindFormatProfileProcInfo, (theFormat), (searchData), (index), (returnedProfile), (numProfiles))
#else
#define CallGXFindFormatProfileProc(userRoutine, theFormat, searchData, index, returnedProfile, numProfiles)        \
        (*(userRoutine))((theFormat), (searchData), (index), (returnedProfile), (numProfiles))
#endif
#define Send_GXFindFormatProfile(theFormat, searchData, index, returnedProfile, numProfiles) \
          SendMessage(0x00000043, theFormat, searchData, index, returnedProfile, numProfiles)

#define Forward_GXFindFormatProfile(theFormat, searchData, index, returnedProfile, numProfiles) \
          ForwardThisMessage((void *) (theFormat), (void *) (searchData), (void *) (index), (void *) (returnedProfile), \
                                      (void *) (numProfiles))
typedef OSErr (*GXSetPrinterProfileProcPtr)(gxPrinter thePrinter, gxColorProfile oldProfile, gxColorProfile newProfile);

#if GENERATINGCFM
typedef UniversalProcPtr GXSetPrinterProfileUPP;
#else
typedef GXSetPrinterProfileProcPtr GXSetPrinterProfileUPP;
#endif

enum {
    uppGXSetPrinterProfileProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrinter)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxColorProfile)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxColorProfile)))
};

#if GENERATINGCFM
#define NewGXSetPrinterProfileProc(userRoutine)        \
        (GXSetPrinterProfileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSetPrinterProfileProcInfo, GetCurrentArchitecture())
#else
#define NewGXSetPrinterProfileProc(userRoutine)        \
        ((GXSetPrinterProfileUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXSetPrinterProfileProc(userRoutine, thePrinter, oldProfile, newProfile)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSetPrinterProfileProcInfo, (thePrinter), (oldProfile), (newProfile))
#else
#define CallGXSetPrinterProfileProc(userRoutine, thePrinter, oldProfile, newProfile)        \
        (*(userRoutine))((thePrinter), (oldProfile), (newProfile))
#endif
#define Send_GXSetPrinterProfile(thePrinter, oldProfile, newProfile) \
          SendMessage(0x00000044, thePrinter, oldProfile, newProfile)

#define Forward_GXSetPrinterProfile(thePrinter, oldProfile, newProfile) \
          ForwardThisMessage((void *) (thePrinter), (void *) (oldProfile), (void *) (newProfile))
typedef OSErr (*GXSetFormatProfileProcPtr)(gxFormat theFormat, gxColorProfile oldProfile, gxColorProfile newProfile);

#if GENERATINGCFM
typedef UniversalProcPtr GXSetFormatProfileUPP;
#else
typedef GXSetFormatProfileProcPtr GXSetFormatProfileUPP;
#endif

enum {
    uppGXSetFormatProfileProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxColorProfile)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxColorProfile)))
};

#if GENERATINGCFM
#define NewGXSetFormatProfileProc(userRoutine)        \
        (GXSetFormatProfileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSetFormatProfileProcInfo, GetCurrentArchitecture())
#else
#define NewGXSetFormatProfileProc(userRoutine)        \
        ((GXSetFormatProfileUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXSetFormatProfileProc(userRoutine, theFormat, oldProfile, newProfile)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSetFormatProfileProcInfo, (theFormat), (oldProfile), (newProfile))
#else
#define CallGXSetFormatProfileProc(userRoutine, theFormat, oldProfile, newProfile)        \
        (*(userRoutine))((theFormat), (oldProfile), (newProfile))
#endif
#define Send_GXSetFormatProfile(theFormat, oldProfile, newProfile) \
          SendMessage(0x00000045, theFormat, oldProfile, newProfile)

#define Forward_GXSetFormatProfile(theFormat, oldProfile, newProfile) \
          ForwardThisMessage((void *) (theFormat), (void *) (oldProfile), (void *) (newProfile))
typedef OSErr (*GXHandleAltDestinationProcPtr)(Boolean *userCancels);

#if GENERATINGCFM
typedef UniversalProcPtr GXHandleAltDestinationUPP;
#else
typedef GXHandleAltDestinationProcPtr GXHandleAltDestinationUPP;
#endif

enum {
    uppGXHandleAltDestinationProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Boolean *)))
};

#if GENERATINGCFM
#define NewGXHandleAltDestinationProc(userRoutine)        \
        (GXHandleAltDestinationUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXHandleAltDestinationProcInfo, GetCurrentArchitecture())
#else
#define NewGXHandleAltDestinationProc(userRoutine)        \
        ((GXHandleAltDestinationUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXHandleAltDestinationProc(userRoutine, userCancels)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXHandleAltDestinationProcInfo, (userCancels))
#else
#define CallGXHandleAltDestinationProc(userRoutine, userCancels)        \
        (*(userRoutine))((userCancels))
#endif
#define Send_GXHandleAltDestination(userCancels) SendMessage(0x00000046, userCancels)
#define Forward_GXHandleAltDestination(userCancels) ForwardThisMessage((void *) (userCancels))
typedef OSErr (*GXSetupPageImageDataProcPtr)(gxFormat theFormat, gxShape thePage, void *imageData);

#if GENERATINGCFM
typedef UniversalProcPtr GXSetupPageImageDataUPP;
#else
typedef GXSetupPageImageDataProcPtr GXSetupPageImageDataUPP;
#endif

enum {
    uppGXSetupPageImageDataProcInfo = kCStackBased
         | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxShape)))
         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
};

#if GENERATINGCFM
#define NewGXSetupPageImageDataProc(userRoutine)        \
        (GXSetupPageImageDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSetupPageImageDataProcInfo, GetCurrentArchitecture())
#else
#define NewGXSetupPageImageDataProc(userRoutine)        \
        ((GXSetupPageImageDataUPP) (userRoutine))
#endif

#if GENERATINGCFM
#define CallGXSetupPageImageDataProc(userRoutine, theFormat, thePage, imageData)        \
        CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSetupPageImageDataProcInfo, (theFormat), (thePage), (imageData))
#else
#define CallGXSetupPageImageDataProc(userRoutine, theFormat, thePage, imageData)        \
        (*(userRoutine))((theFormat), (thePage), (imageData))
#endif
#define Send_GXSetupPageImageData(theFormat, thePage, imageData) \
          SendMessage(0x00000047, theFormat, thePage, imageData)

#define Forward_GXSetupPageImageData(theFormat, thePage, imageData) \
          ForwardThisMessage((void *) (theFormat), (void *) (thePage), (void *) (imageData))
/*
******************************************************************
                    Start of old "GXPrintingErrors.h/a/p" interface file.
            *******************************************************************
*/

enum {
    gxPrintingResultBase        = -510                            /*First QuickDraw GX printing error code.*/
};

/*RESULT CODES FOR QUICKDRAW GX PRINTING OPERATIONS*/

enum {
    gxAioTimeout                = (gxPrintingResultBase),        /*-510 : Timeout condition occurred during operation*/
    gxAioBadRqstState            = (gxPrintingResultBase - 1),    /*-511 : Async I/O request in invalid state for operation*/
    gxAioBadConn                = (gxPrintingResultBase - 2),    /*-512 : Invalid Async I/O connection refnum*/
    gxAioInvalidXfer            = (gxPrintingResultBase - 3),    /*-513 : Read data transfer structure contained bad values*/
    gxAioNoRqstBlks                = (gxPrintingResultBase - 4),    /*-514 : No available request blocks to process request*/
    gxAioNoDataXfer                = (gxPrintingResultBase - 5),    /*-515 : Data transfer structure pointer not specified*/
    gxAioTooManyAutos            = (gxPrintingResultBase - 6),    /*-516 : Auto status request already active*/
    gxAioNoAutoStat                = (gxPrintingResultBase - 7),    /*-517 : Connection not configured for auto status*/
    gxAioBadRqstID                = (gxPrintingResultBase - 8),    /*-518 : Invalid I/O request identifier*/
    gxAioCantKill                = (gxPrintingResultBase - 9),    /*-519 : Comm. protocol doesn't support I/O term*/
    gxAioAlreadyExists            = (gxPrintingResultBase - 10),    /*-520 : Protocol spec. data already specified*/
    gxAioCantFind                = (gxPrintingResultBase - 11),    /*-521 : Protocol spec. data does not exist*/
    gxAioDeviceDisconn            = (gxPrintingResultBase - 12),    /*-522 : Machine disconnected from printer*/
    gxAioNotImplemented            = (gxPrintingResultBase - 13),    /*-523 : Function not implemented*/
    gxAioOpenPending            = (gxPrintingResultBase - 14),    /*-524 : Opening a connection for protocol, but another open pending*/
    gxAioNoProtocolData            = (gxPrintingResultBase - 15),    /*-525 : No protocol specific data specified in request*/
    gxAioRqstKilled                = (gxPrintingResultBase - 16),    /*-526 : I/O request was terminated*/
    gxBadBaudRate                = (gxPrintingResultBase - 17),    /*-527 : Invalid baud rate specified*/
    gxBadParity                    = (gxPrintingResultBase - 18),    /*-528 : Invalid parity specified*/
    gxBadStopBits                = (gxPrintingResultBase - 19),    /*-529 : Invalid stop bits specified*/
    gxBadDataBits                = (gxPrintingResultBase - 20),    /*-530 : Invalid data bits specified*/
    gxBadPrinterName            = (gxPrintingResultBase - 21),    /*-531 : Bad printer name specified*/
    gxAioBadMsgType                = (gxPrintingResultBase - 22),    /*-532 : Bad masType field in transfer info structure*/
    gxAioCantFindDevice            = (gxPrintingResultBase - 23),    /*-533 : Cannot locate target device*/
    gxAioOutOfSeq                = (gxPrintingResultBase - 24),    /*-534 : Non-atomic SCSI requests submitted out of sequence*/
    gxPrIOAbortErr                = (gxPrintingResultBase - 25),    /*-535 : I/O operation aborted*/
    gxPrUserAbortErr            = (gxPrintingResultBase - 26),    /*-536 : User aborted*/
    gxCantAddPanelsNowErr        = (gxPrintingResultBase - 27),    /*-537 : Can only add panels during driver switch or dialog setup*/
    gxBadxdtlKeyErr                = (gxPrintingResultBase - 28),    /*-538 : Unknown key for xdtl - must be radiobutton, etc*/
    gxXdtlItemOutOfRangeErr        = (gxPrintingResultBase - 29),    /*-539 : Referenced item does not belong to panel*/
    gxNoActionButtonErr            = (gxPrintingResultBase - 30),    /*-540 : Action button is nil*/
    gxTitlesTooLongErr            = (gxPrintingResultBase - 31),    /*-541 : Length of buttons exceeds alert maximum width*/
    gxUnknownAlertVersionErr    = (gxPrintingResultBase - 32),    /*-542 : Bad version for printing alerts*/
    gxGBBufferTooSmallErr        = (gxPrintingResultBase - 33),    /*-543 : Buffer too small.*/
    gxInvalidPenTable            = (gxPrintingResultBase - 34),    /*-544 : Invalid vector driver pen table.*/
    gxIncompletePrintFileErr    = (gxPrintingResultBase - 35),    /*-545 : Print file was not completely spooled*/
    gxCrashedPrintFileErr        = (gxPrintingResultBase - 36),    /*-546 : Print file is corrupted*/
    gxInvalidPrintFileVersion    = (gxPrintingResultBase - 37),    /*-547 : Print file is incompatible with current QuickDraw GX version*/
    gxSegmentLoadFailedErr        = (gxPrintingResultBase - 38),    /*-548 : Segment loader error*/
    gxExtensionNotFoundErr        = (gxPrintingResultBase - 39),    /*-549 : Requested printing extension could not be found*/
    gxDriverVersionErr            = (gxPrintingResultBase - 40),    /*-550 : Driver too new for current version of QuickDraw GX*/
    gxImagingSystemVersionErr    = (gxPrintingResultBase - 41),    /*-551 : Imaging system too new for current version of QuickDraw GX*/
    gxFlattenVersionTooNew        = (gxPrintingResultBase - 42),    /*-552 : Flattened object format too new for current version of QDGX*/
    gxPaperTypeNotFound            = (gxPrintingResultBase - 43),    /*-553 : Requested papertype could not be found*/
    gxNoSuchPTGroup                = (gxPrintingResultBase - 44),    /*-554 : Requested papertype group could not be found*/
    gxNotEnoughPrinterMemory    = (gxPrintingResultBase - 45),    /*-555 : Printer does not have enough memory for fonts in document*/
    gxDuplicatePanelNameErr        = (gxPrintingResultBase - 46),    /*-556 : Attempt to add more than 10 panels with the same name*/
    gxExtensionVersionErr        = (gxPrintingResultBase - 47)    /*-557 : Extension too new for current version of QuickDraw GX*/
};

#endif

#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=reset
#endif

#if PRAGMA_IMPORT_SUPPORTED
#pragma import off
#endif

#ifdef __cplusplus
}
#endif

#endif /* __GXPRINTING__ */